diff --git a/src/V3Ast.h b/src/V3Ast.h
index e404cf5cf..223d44d2f 100644
--- a/src/V3Ast.h
+++ b/src/V3Ast.h
@@ -157,12 +157,10 @@ public:
     typename std::enable_if<std::is_pointer<T>::value, T>::type to() const VL_MT_SAFE {
         return reinterpret_cast<T>(m_u.up);
     }
-    WidthVP* c() const { return to<WidthVP*>(); }
     VSymEnt* toSymEnt() const { return to<VSymEnt*>(); }
     AstNode* toNodep() const VL_MT_SAFE { return to<AstNode*>(); }
     V3GraphVertex* toGraphVertex() const { return to<V3GraphVertex*>(); }
     int toInt() const { return m_u.ui; }
-    static VNUser fromInt(int i) { return VNUser{i}; }
 };
 
 //######################################################################
@@ -358,7 +356,6 @@ public:
             UASSERT_STATIC(!m_backp, "Active linker must be relink()ed before destruction"););
     }
     inline void relink(AstNode* newp);
-    AstNode* oldp() const { return m_oldp; }
     void dump(std::ostream& str = std::cout) const;
 };
 inline std::ostream& operator<<(std::ostream& os, const VNRelinker& rhs) {
@@ -967,21 +964,21 @@ protected:
 
     // For internal use only.
     template <typename T_TargetType, typename T_DeclType>
-    constexpr static bool uselessCast() VL_PURE {
+    constexpr static bool uselessCast() VL_PURE {  // LCOV_EXCL_START
         using NonRef = typename std::remove_reference<T_DeclType>::type;
         using NonPtr = typename std::remove_pointer<NonRef>::type;
         using NonCV = typename std::remove_cv<NonPtr>::type;
         return std::is_base_of<T_TargetType, NonCV>::value;
-    }
+    }  // LCOV_EXCL_STOP
 
     // For internal use only.
     template <typename T_TargetType, typename T_DeclType>
-    constexpr static bool impossibleCast() VL_PURE {
+    constexpr static bool impossibleCast() VL_PURE {  // LCOV_EXCL_START
         using NonRef = typename std::remove_reference<T_DeclType>::type;
         using NonPtr = typename std::remove_pointer<NonRef>::type;
         using NonCV = typename std::remove_cv<NonPtr>::type;
         return !std::is_base_of<NonCV, T_TargetType>::value;
-    }
+    }  // LCOV_EXCL_STOP
 
 public:
     // For use via the VN_IS macro only, or in templated code
diff --git a/src/V3AstAttr.h b/src/V3AstAttr.h
index 0cc5de1e7..a0591ed4d 100644
--- a/src/V3AstAttr.h
+++ b/src/V3AstAttr.h
@@ -1439,38 +1439,6 @@ inline std::ostream& operator<<(std::ostream& os, const VNumRange& rhs) {
 
 // ######################################################################
 
-class VParseRefExp final {
-public:
-    enum en : uint8_t {
-        PX_NONE,  // Used in V3LinkParse only
-        PX_ROOT,
-        PX_TEXT  // Unknown ID component
-    };
-    enum en m_e;
-    VParseRefExp()
-        : m_e{PX_NONE} {}
-    // cppcheck-suppress noExplicitConstructor
-    constexpr VParseRefExp(en _e)
-        : m_e{_e} {}
-    explicit VParseRefExp(int _e)
-        : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
-    constexpr operator en() const { return m_e; }
-    const char* ascii() const {
-        static const char* const names[] = {"", "$root", "TEXT", "PREDOT"};
-        return names[m_e];
-    }
-};
-constexpr bool operator==(const VParseRefExp& lhs, const VParseRefExp& rhs) {
-    return lhs.m_e == rhs.m_e;
-}
-constexpr bool operator==(const VParseRefExp& lhs, VParseRefExp::en rhs) { return lhs.m_e == rhs; }
-constexpr bool operator==(VParseRefExp::en lhs, const VParseRefExp& rhs) { return lhs == rhs.m_e; }
-inline std::ostream& operator<<(std::ostream& os, const VParseRefExp& rhs) {
-    return os << rhs.ascii();
-}
-
-// ######################################################################
-
 class VPragmaType final {
 public:
     enum en : uint8_t {
diff --git a/src/V3AstInlines.h b/src/V3AstInlines.h
index 6061ce315..f04f31002 100644
--- a/src/V3AstInlines.h
+++ b/src/V3AstInlines.h
@@ -102,13 +102,6 @@ int AstRange::rightConst() const VL_MT_STABLE {
     return (constp ? constp->toSInt() : 0);
 }
 
-AstPin::AstPin(FileLine* fl, int pinNum, AstVarRef* varname, AstNode* exprp)
-    : ASTGEN_SUPER_Pin(fl)
-    , m_pinNum{pinNum}
-    , m_name{varname->name()} {
-    this->exprp(exprp);
-}
-
 AstPackArrayDType::AstPackArrayDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp,
                                      AstRange* rangep)
     : ASTGEN_SUPER_PackArrayDType(fl) {
diff --git a/src/V3AstNodeExpr.h b/src/V3AstNodeExpr.h
index 114f2f4cd..2538c79c6 100644
--- a/src/V3AstNodeExpr.h
+++ b/src/V3AstNodeExpr.h
@@ -85,8 +85,6 @@ protected:
 
 public:
     ASTGEN_MEMBERS_AstNodeBiop;
-    // Clone single node, just get same type back.
-    virtual AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) = 0;
     // METHODS
     // Set out to evaluation of a AstConst'ed
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) = 0;
@@ -137,13 +135,7 @@ public:
     bool sizeMattersLhs() const override { return false; }
     bool sizeMattersRhs() const override { return false; }
     int instrCount() const override { return INSTR_COUNT_DBL_TRIG; }
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        V3ERROR_NA;
-        return nullptr;
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
 };
 class AstNodeSel VL_NOT_FINAL : public AstNodeBiop {
     // Single bit range extraction, perhaps with non-constant selection or array selection
@@ -240,11 +232,6 @@ private:
     VIsCached m_purity;  // Pure state
 
 protected:
-    AstNodeFTaskRef(VNType t, FileLine* fl, AstNode* namep, AstNodeExpr* pinsp)
-        : AstNodeExpr{t, fl} {
-        this->namep(namep);
-        addPinsp(pinsp);
-    }
     AstNodeFTaskRef(VNType t, FileLine* fl, const string& name, AstNodeExpr* pinsp)
         : AstNodeExpr{t, fl}
         , m_name{name} {
@@ -360,11 +347,6 @@ protected:
 
 public:
     ASTGEN_MEMBERS_AstNodeTermop;
-    // Know no children, and hot function, so skip iterator for speed
-    // cppcheck-suppress functionConst
-    void iterateChildren(VNVisitorConst& v) {}
-    void dump(std::ostream& str) const override;
-    void dumpJson(std::ostream& str) const override;
 };
 class AstNodeTriop VL_NOT_FINAL : public AstNodeExpr {
     // Ternary expression
@@ -482,11 +464,6 @@ private:
         = VSelfPointerText{VSelfPointerText::Empty()};  // Output code object
                                                         // pointer (e.g.: 'this')
 protected:
-    AstNodeVarRef(VNType t, FileLine* fl, const VAccess& access)
-        : AstNodeExpr{t, fl}
-        , m_access{access} {
-        varp(nullptr);
-    }
     AstNodeVarRef(VNType t, FileLine* fl, AstVar* varp, const VAccess& access)
         : AstNodeExpr{t, fl}
         , m_access{access} {
@@ -514,9 +491,6 @@ public:
     }
     AstNodeModule* classOrPackagep() const { return m_classOrPackagep; }
     void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; }
-    // Know no children, and hot function, so skip iterator for speed
-    // cppcheck-suppress functionConst
-    void iterateChildren(VNVisitorConst& v) {}
     static AstNodeVarRef* varRefLValueRecurse(AstNode* nodep);
 };
 
@@ -769,7 +743,6 @@ public:
     AstNodeModule* classOrPackageSkipp() const;
     AstNode* classOrPackageNodep() const { return m_classOrPackageNodep; }
     void classOrPackageNodep(AstNode* nodep) { m_classOrPackageNodep = nodep; }
-    AstPackage* packagep() const { return VN_CAST(classOrPackageNodep(), Package); }
     void classOrPackagep(AstNodeModule* nodep) {
         m_classOrPackageNodep = reinterpret_cast<AstNode*>(nodep);
     }
@@ -805,12 +778,6 @@ public:
         : ASTGEN_SUPER_ConsDynArray(fl)
         , m_lhsIsValue{false}
         , m_rhsIsValue{false} {}
-    explicit AstConsDynArray(FileLine* fl, bool lhsIsValue, AstNode* lhsp)
-        : ASTGEN_SUPER_ConsDynArray(fl)
-        , m_lhsIsValue{lhsIsValue}
-        , m_rhsIsValue{false} {
-        this->lhsp(lhsp);
-    }
     explicit AstConsDynArray(FileLine* fl, bool lhsIsValue, AstNode* lhsp, bool rhsIsValue,
                              AstNode* rhsp)
         : ASTGEN_SUPER_ConsDynArray(fl)
@@ -890,12 +857,6 @@ public:
         : ASTGEN_SUPER_ConsQueue(fl)
         , m_lhsIsValue{false}
         , m_rhsIsValue{false} {}
-    explicit AstConsQueue(FileLine* fl, bool lhsIsValue, AstNode* lhsp)
-        : ASTGEN_SUPER_ConsQueue(fl)
-        , m_lhsIsValue{lhsIsValue}
-        , m_rhsIsValue{false} {
-        this->lhsp(lhsp);
-    }
     explicit AstConsQueue(FileLine* fl, bool lhsIsValue, AstNode* lhsp, bool rhsIsValue,
                           AstNode* rhsp)
         : ASTGEN_SUPER_ConsQueue(fl)
@@ -1113,6 +1074,7 @@ public:
     AstConstraint* constrp() const VL_MT_STABLE { return m_constrp; }
     void constrp(AstConstraint* nodep) { m_constrp = nodep; }
     AstNodeModule* classOrPackagep() const VL_MT_STABLE { return m_classOrPackagep; }
+    // TODO: this setter is unused
     void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; }
 
     string emitVerilog() final override { V3ERROR_NA_RETURN(""); }
@@ -1762,29 +1724,23 @@ class AstParseRef final : public AstNodeExpr {
     // @astgen op1 := lhsp : Optional[AstNode]
     // @astgen op2 := ftaskrefp : Optional[AstNodeFTaskRef]
 
-    VParseRefExp m_expect;  // Type we think it should resolve to
     string m_name;
 
 public:
-    AstParseRef(FileLine* fl, VParseRefExp expect, const string& name, AstNode* lhsp = nullptr,
+    AstParseRef(FileLine* fl, const string& name, AstNode* lhsp = nullptr,
                 AstNodeFTaskRef* ftaskrefp = nullptr)
         : ASTGEN_SUPER_ParseRef(fl)
-        , m_expect{expect}
         , m_name{name} {
         this->lhsp(lhsp);
         this->ftaskrefp(ftaskrefp);
     }
     ASTGEN_MEMBERS_AstParseRef;
-    void dump(std::ostream& str) const override;
-    void dumpJson(std::ostream& str) const override;
     string name() const override VL_MT_STABLE { return m_name; }  // * = Var name
+    void name(const string& name) override { m_name = name; }
     bool sameNode(const AstNode* samep) const override {
         const AstParseRef* const asamep = VN_DBG_AS(samep, ParseRef);
-        return (expect() == asamep->expect() && m_name == asamep->m_name);
+        return m_name == asamep->m_name;
     }
-    void name(const string& name) override { m_name = name; }
-    VParseRefExp expect() const { return m_expect; }
-    void expect(VParseRefExp exp) { m_expect = exp; }
 
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -2043,7 +1999,6 @@ public:
         return text() == asamep->text() && timeunit() == asamep->timeunit();
     }
     string text() const { return m_text; }  // * = Text to display
-    void text(const string& text) { m_text = text; }
     VTimescale timeunit() const { return m_timeunit; }
     void timeunit(const VTimescale& flag) { m_timeunit = flag; }
 };
@@ -2323,7 +2278,6 @@ public:
     bool sameNode(const AstNode* /*samep*/) const override { return true; }
     bool cleanOut() const override { return true; }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const VL_MT_STABLE { return dtypep() ? dtypep() : childDTypep(); }
 };
 class AstTimePrecision final : public AstNodeExpr {
     // Verilog $timeprecision
@@ -2496,9 +2450,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstBufIf1;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstBufIf1{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opBufIf1(lhs, rhs);
     }
@@ -2526,9 +2477,6 @@ public:
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         V3ERROR_NA;
     }
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstCastDynamic{fileline(), lhsp, rhsp};
-    }
     string emitVerilog() override { return "%f$cast(%r, %l)"; }
     string emitC() override { return "VL_DYNAMIC_CAST(%r, %l)"; }
     bool cleanOut() const override { return true; }
@@ -2549,9 +2497,6 @@ public:
         dtypeSetUInt32();
     }
     ASTGEN_MEMBERS_AstCompareNN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstCompareNN{fileline(), lhsp, rhsp, m_ignoreCase};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opCompareNN(lhs, rhs, m_ignoreCase);
     }
@@ -2580,9 +2525,6 @@ public:
         }
     }
     ASTGEN_MEMBERS_AstConcat;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstConcat{fileline(), lhsp, rhsp};
-    }
     string emitVerilog() override { return "%f{%l, %k%r}"; }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opConcat(lhs, rhs);
@@ -2604,9 +2546,6 @@ public:
         dtypeSetString();
     }
     ASTGEN_MEMBERS_AstConcatN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstConcatN{fileline(), lhsp, rhsp};
-    }
     string emitVerilog() override { return "%f{%l, %k%r}"; }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opConcatN(lhs, rhs);
@@ -2627,9 +2566,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstDiv;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstDiv{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opDiv(lhs, rhs);
     }
@@ -2651,9 +2587,6 @@ public:
         dtypeSetDouble();
     }
     ASTGEN_MEMBERS_AstDivD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstDivD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opDivD(lhs, rhs);
     }
@@ -2675,9 +2608,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstDivS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstDivS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opDivS(lhs, rhs);
     }
@@ -2701,9 +2631,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstEqWild;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstEqWild{fileline(), lhsp, rhsp};
-    }
     // Return AstEqWild/AstEqD
     static AstNodeBiop* newTyped(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp);
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
@@ -2724,12 +2651,7 @@ public:
     AstFGetS(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp)
         : ASTGEN_SUPER_FGetS(fl, lhsp, rhsp) {}
     ASTGEN_MEMBERS_AstFGetS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstFGetS{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%f$fgets(%l,%r)"; }
     string emitC() override {
         return strgp()->dtypep()->basicp()->isString() ? "VL_FGETS_NI(%li, %ri)"
@@ -2749,12 +2671,7 @@ public:
     AstFUngetC(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp)
         : ASTGEN_SUPER_FUngetC(fl, lhsp, rhsp) {}
     ASTGEN_MEMBERS_AstFUngetC;
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstFUngetC{fileline(), lhsp, rhsp};
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%f$ungetc(%r, %l)"; }
     // Non-existent filehandle returns EOF
     string emitC() override {
@@ -2779,9 +2696,6 @@ public:
         dtypeSetBitSized(8, VSigning::UNSIGNED);
     }
     ASTGEN_MEMBERS_AstGetcN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGetcN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGetcN(lhs, rhs);
     }
@@ -2804,12 +2718,7 @@ public:
         dtypeSetBitSized(8, VSigning::UNSIGNED);
     }
     ASTGEN_MEMBERS_AstGetcRefN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGetcRefN{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%k%l[%r]"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { return ""; }
@@ -2826,9 +2735,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGt;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGt{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGt(lhs, rhs);
     }
@@ -2849,9 +2755,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGtD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGtD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGtD(lhs, rhs);
     }
@@ -2873,9 +2776,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGtN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGtN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGtN(lhs, rhs);
     }
@@ -2897,9 +2797,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGtS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGtS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGtS(lhs, rhs);
     }
@@ -2921,9 +2818,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGte;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGte{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGte(lhs, rhs);
     }
@@ -2944,9 +2838,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGteD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGteD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGteD(lhs, rhs);
     }
@@ -2968,9 +2859,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGteN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGteN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGteN(lhs, rhs);
     }
@@ -2992,9 +2880,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstGteS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstGteS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opGteS(lhs, rhs);
     }
@@ -3016,9 +2901,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLogAnd;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLogAnd{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLogAnd(lhs, rhs);
     }
@@ -3040,9 +2922,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLogIf;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLogIf{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLogIf(lhs, rhs);
     }
@@ -3064,9 +2943,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLogOr;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLogOr{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLogOr(lhs, rhs);
     }
@@ -3088,9 +2964,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLt;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLt{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLt(lhs, rhs);
     }
@@ -3111,9 +2984,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLtD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLtD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLtD(lhs, rhs);
     }
@@ -3135,9 +3005,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLtN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLtN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLtN(lhs, rhs);
     }
@@ -3159,9 +3026,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLtS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLtS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLtS(lhs, rhs);
     }
@@ -3183,9 +3047,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLte;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLte{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLte(lhs, rhs);
     }
@@ -3206,9 +3067,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLteD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLteD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLteD(lhs, rhs);
     }
@@ -3230,9 +3088,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLteN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLteN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLteN(lhs, rhs);
     }
@@ -3254,9 +3109,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLteS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLteS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLteS(lhs, rhs);
     }
@@ -3278,9 +3130,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstModDiv;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstModDiv{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opModDiv(lhs, rhs);
     }
@@ -3302,9 +3151,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstModDivS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstModDivS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opModDivS(lhs, rhs);
     }
@@ -3327,9 +3173,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstNeqWild;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstNeqWild{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opWildNeq(lhs, rhs);
     }
@@ -3349,9 +3192,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstPow;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstPow{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opPow(lhs, rhs);
     }
@@ -3372,9 +3212,6 @@ public:
         dtypeSetDouble();
     }
     ASTGEN_MEMBERS_AstPowD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstPowD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opPowD(lhs, rhs);
     }
@@ -3395,9 +3232,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstPowSS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstPowSS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opPowSS(lhs, rhs);
     }
@@ -3419,9 +3253,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstPowSU;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstPowSU{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opPowSU(lhs, rhs);
     }
@@ -3443,9 +3274,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstPowUS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstPowUS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opPowUS(lhs, rhs);
     }
@@ -3482,9 +3310,6 @@ public:
     AstReplicate(FileLine* fl, AstNodeExpr* lhsp, uint32_t repCount)
         : AstReplicate{fl, lhsp, new AstConst{fl, repCount}} {}
     ASTGEN_MEMBERS_AstReplicate;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstReplicate{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opRepl(lhs, rhs);
     }
@@ -3507,12 +3332,7 @@ public:
         : ASTGEN_SUPER_ReplicateN(fl, lhsp, rhsp) {
         dtypeSetString();
     }
-    AstReplicateN(FileLine* fl, AstNodeExpr* lhsp, uint32_t repCount)
-        : AstReplicateN{fl, lhsp, new AstConst{fl, repCount}} {}
     ASTGEN_MEMBERS_AstReplicateN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstReplicateN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opReplN(lhs, rhs);
     }
@@ -3549,9 +3369,6 @@ public:
         dtypeSetLogicSized(bitwidth, VSigning::UNSIGNED);
     }
     ASTGEN_MEMBERS_AstSel;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstSel{fileline(), lhsp, rhsp, widthConst()};
-    }
     void dump(std::ostream& str) const override;
     void dumpJson(std::ostream& str) const override;
     void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit) override {
@@ -3592,9 +3409,6 @@ public:
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED);
     }
     ASTGEN_MEMBERS_AstShiftL;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstShiftL{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opShiftL(lhs, rhs);
     }
@@ -3619,9 +3433,6 @@ public:
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED);
     }
     ASTGEN_MEMBERS_AstShiftLOvr;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstShiftLOvr{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opShiftL(lhs, rhs);
     }
@@ -3641,9 +3452,6 @@ public:
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED);
     }
     ASTGEN_MEMBERS_AstShiftR;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstShiftR{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opShiftR(lhs, rhs);
     }
@@ -3669,9 +3477,6 @@ public:
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED);
     }
     ASTGEN_MEMBERS_AstShiftROvr;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstShiftROvr{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opShiftR(lhs, rhs);
     }
@@ -3695,9 +3500,6 @@ public:
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::SIGNED);
     }
     ASTGEN_MEMBERS_AstShiftRS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstShiftRS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opShiftRS(lhs, rhs, lhsp()->widthMinV());
     }
@@ -3723,9 +3525,6 @@ public:
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::SIGNED);
     }
     ASTGEN_MEMBERS_AstShiftRSOvr;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstShiftRSOvr{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opShiftRS(lhs, rhs, lhsp()->widthMinV());
     }
@@ -3746,9 +3545,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstSub;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstSub{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opSub(lhs, rhs);
     }
@@ -3769,9 +3565,6 @@ public:
         dtypeSetDouble();
     }
     ASTGEN_MEMBERS_AstSubD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstSubD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opSubD(lhs, rhs);
     }
@@ -3794,12 +3587,7 @@ public:
         dtypeSetUInt32();  // Says IEEE
     }
     ASTGEN_MEMBERS_AstURandomRange;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstURandomRange{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%f$urandom_range(%l, %r)"; }
     string emitC() override { return "VL_URANDOM_RANGE_%nq(%li, %ri)"; }
     bool cleanOut() const override { return true; }
@@ -3821,9 +3609,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstEq;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstEq{fileline(), lhsp, rhsp};
-    }
     // Return AstEq/AstEqD
     static AstNodeBiop* newTyped(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp);
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
@@ -3846,9 +3631,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstEqCase;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstEqCase{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opCaseEq(lhs, rhs);
     }
@@ -3868,9 +3650,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstEqD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstEqD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opEqD(lhs, rhs);
     }
@@ -3892,9 +3671,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstEqN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstEqN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opEqN(lhs, rhs);
     }
@@ -3917,12 +3693,7 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstEqT;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstEqT{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%k(%l %f== %r)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { return "=="; }
@@ -3940,9 +3711,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstLogEq;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstLogEq{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opLogEq(lhs, rhs);
     }
@@ -3964,9 +3732,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstNeq;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstNeq{fileline(), lhsp, rhsp};
-    }
     static AstNodeBiop* newTyped(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp);
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opNeq(lhs, rhs);
@@ -3988,9 +3753,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstNeqCase;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstNeqCase{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opCaseNeq(lhs, rhs);
     }
@@ -4010,9 +3772,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstNeqD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstNeqD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opNeqD(lhs, rhs);
     }
@@ -4034,9 +3793,6 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstNeqN;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstNeqN{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opNeqN(lhs, rhs);
     }
@@ -4059,12 +3815,7 @@ public:
         dtypeSetBit();
     }
     ASTGEN_MEMBERS_AstNeqT;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstNeqT{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%k(%l %f!= %r)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { return "!="; }
@@ -4084,9 +3835,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstAdd;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstAdd{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opAdd(lhs, rhs);
     }
@@ -4107,9 +3855,6 @@ public:
         dtypeSetDouble();
     }
     ASTGEN_MEMBERS_AstAddD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstAddD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opAddD(lhs, rhs);
     }
@@ -4131,9 +3876,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstAnd;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstAnd{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opAnd(lhs, rhs);
     }
@@ -4155,9 +3897,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstMul;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstMul{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opMul(lhs, rhs);
     }
@@ -4179,9 +3918,6 @@ public:
         dtypeSetDouble();
     }
     ASTGEN_MEMBERS_AstMulD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstMulD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opMulD(lhs, rhs);
     }
@@ -4203,9 +3939,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstMulS;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstMulS{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opMulS(lhs, rhs);
     }
@@ -4228,9 +3961,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstOr;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstOr{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opOr(lhs, rhs);
     }
@@ -4252,9 +3982,6 @@ public:
         dtypeFrom(lhsp);
     }
     ASTGEN_MEMBERS_AstXor;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstXor{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opXor(lhs, rhs);
     }
@@ -4323,12 +4050,7 @@ public:
         init(fromp);
     }
     ASTGEN_MEMBERS_AstArraySel;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstArraySel{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;  // How can from be a const?
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%k(%l%f[%r])"; }
     string emitC() override { return "%li%k[%ri]"; }
     string emitSMT() const override { return "(select %l %r)"; }
@@ -4359,12 +4081,7 @@ public:
         init(fromp);
     }
     ASTGEN_MEMBERS_AstAssocSel;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstAssocSel{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%k(%l%f[%r])"; }
     string emitC() override { return "%li%k[%ri]"; }
     string emitSMT() const override { return "(select %l %r)"; }
@@ -4393,12 +4110,7 @@ public:
         init(fromp);
     }
     ASTGEN_MEMBERS_AstWildcardSel;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstWildcardSel{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%k(%l%f[%r])"; }
     string emitC() override { return "%li%k[%ri]"; }
     bool cleanOut() const override { return true; }
@@ -4419,12 +4131,7 @@ public:
         dtypeSetUInt32();  // Always used on WData arrays so returns edata size
     }
     ASTGEN_MEMBERS_AstWordSel;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstWordSel{fileline(), lhsp, rhsp};
-    }
-    void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit) override {
-        V3ERROR_NA;
-    }
+    void numberOperate(V3Number&, const V3Number&, const V3Number&) override { V3ERROR_NA; }
     string emitVerilog() override { return "%k(%l%f[%r])"; }
     string emitC() override {
         return "%li[%ri]";
@@ -4444,9 +4151,6 @@ public:
     AstStreamL(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp)
         : ASTGEN_SUPER_StreamL(fl, lhsp, rhsp) {}
     ASTGEN_MEMBERS_AstStreamL;
-    AstNodeStream* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstStreamL{fileline(), lhsp, rhsp};
-    }
     string emitVerilog() override { return "%f{ << %r %k{%l} }"; }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opStreamL(lhs, rhs);
@@ -4465,9 +4169,6 @@ public:
     AstStreamR(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp)
         : ASTGEN_SUPER_StreamR(fl, lhsp, rhsp) {}
     ASTGEN_MEMBERS_AstStreamR;
-    AstNodeStream* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstStreamR{fileline(), lhsp, rhsp};
-    }
     string emitVerilog() override { return "%f{ >> %r %k{%l} }"; }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opAssign(lhs);
@@ -4487,9 +4188,6 @@ public:
     AstAtan2D(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp)
         : ASTGEN_SUPER_Atan2D(fl, lhsp, rhsp) {}
     ASTGEN_MEMBERS_AstAtan2D;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstAtan2D{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.setDouble(std::atan2(lhs.toDouble(), rhs.toDouble()));
     }
@@ -4501,9 +4199,6 @@ public:
     AstHypotD(FileLine* fl, AstNodeExpr* lhsp, AstNodeExpr* rhsp)
         : ASTGEN_SUPER_HypotD(fl, lhsp, rhsp) {}
     ASTGEN_MEMBERS_AstHypotD;
-    AstNodeExpr* cloneType(AstNodeExpr* lhsp, AstNodeExpr* rhsp) override {
-        return new AstHypotD{fileline(), lhsp, rhsp};
-    }
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.setDouble(std::hypot(lhs.toDouble(), rhs.toDouble()));
     }
@@ -4555,8 +4250,6 @@ class AstFuncRef final : public AstNodeFTaskRef {
     bool m_superReference = false;  // Called with super reference
 public:
     inline AstFuncRef(FileLine* fl, AstFunc* taskp, AstNodeExpr* pinsp);
-    AstFuncRef(FileLine* fl, AstParseRef* namep, AstNodeExpr* pinsp)
-        : ASTGEN_SUPER_FuncRef(fl, reinterpret_cast<AstNode*>(namep), pinsp) {}
     AstFuncRef(FileLine* fl, const string& name, AstNodeExpr* pinsp)
         : ASTGEN_SUPER_FuncRef(fl, name, pinsp) {}
     ASTGEN_MEMBERS_AstFuncRef;
@@ -4606,10 +4299,6 @@ class AstTaskRef final : public AstNodeFTaskRef {
     bool m_superReference = false;  // Called with super reference
 public:
     inline AstTaskRef(FileLine* fl, AstTask* taskp, AstNodeExpr* pinsp);
-    AstTaskRef(FileLine* fl, AstParseRef* namep, AstNodeExpr* pinsp)
-        : ASTGEN_SUPER_TaskRef(fl, reinterpret_cast<AstNode*>(namep), pinsp) {
-        dtypeSetVoid();
-    }
     AstTaskRef(FileLine* fl, const string& name, AstNodeExpr* pinsp)
         : ASTGEN_SUPER_TaskRef(fl, name, pinsp) {
         dtypeSetVoid();
@@ -4794,13 +4483,13 @@ public:
     string emitVerilog() override { return "%k(%r++)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
-    bool cleanOut() const override { return false; }
-    bool cleanLhs() const override { return false; }
-    bool cleanRhs() const override { return false; }
-    bool cleanThs() const override { return false; }
-    bool sizeMattersLhs() const override { return true; }
-    bool sizeMattersRhs() const override { return true; }
-    bool sizeMattersThs() const override { return true; }
+    bool cleanOut() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanLhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanRhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanThs() const override { V3ERROR_NA_RETURN(false); }
+    bool sizeMattersLhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersRhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersThs() const override { V3ERROR_NA_RETURN(true); }
 };
 class AstPostSub final : public AstNodeTriop {
     // Post-decrement/subtract
@@ -4818,13 +4507,13 @@ public:
     string emitVerilog() override { return "%k(%r--)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
-    bool cleanOut() const override { return false; }
-    bool cleanLhs() const override { return false; }
-    bool cleanRhs() const override { return false; }
-    bool cleanThs() const override { return false; }
-    bool sizeMattersLhs() const override { return true; }
-    bool sizeMattersRhs() const override { return true; }
-    bool sizeMattersThs() const override { return true; }
+    bool cleanOut() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanLhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanRhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanThs() const override { V3ERROR_NA_RETURN(false); }
+    bool sizeMattersLhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersRhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersThs() const override { V3ERROR_NA_RETURN(true); }
 };
 class AstPreAdd final : public AstNodeTriop {
     // Pre-increment/add
@@ -4842,13 +4531,13 @@ public:
     string emitVerilog() override { return "%k(++%r)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
-    bool cleanOut() const override { return false; }
-    bool cleanLhs() const override { return false; }
-    bool cleanRhs() const override { return false; }
-    bool cleanThs() const override { return false; }
-    bool sizeMattersLhs() const override { return true; }
-    bool sizeMattersRhs() const override { return true; }
-    bool sizeMattersThs() const override { return true; }
+    bool cleanOut() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanLhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanRhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanThs() const override { V3ERROR_NA_RETURN(false); }
+    bool sizeMattersLhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersRhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersThs() const override { V3ERROR_NA_RETURN(true); }
 };
 class AstPreSub final : public AstNodeTriop {
     // Pre-decrement/subtract
@@ -4866,13 +4555,13 @@ public:
     string emitVerilog() override { return "%k(--%r)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
-    bool cleanOut() const override { return false; }
-    bool cleanLhs() const override { return false; }
-    bool cleanRhs() const override { return false; }
-    bool cleanThs() const override { return false; }
-    bool sizeMattersLhs() const override { return true; }
-    bool sizeMattersRhs() const override { return true; }
-    bool sizeMattersThs() const override { return true; }
+    bool cleanOut() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanLhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanRhs() const override { V3ERROR_NA_RETURN(false); }
+    bool cleanThs() const override { V3ERROR_NA_RETURN(false); }
+    bool sizeMattersLhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersRhs() const override { V3ERROR_NA_RETURN(true); }
+    bool sizeMattersThs() const override { V3ERROR_NA_RETURN(true); }
 };
 class AstPutcN final : public AstNodeTriop {
     // Verilog string.putc()
@@ -4929,7 +4618,6 @@ public:
     // For widthConst()/loConst etc, see declRange().elements() and other VNumRange methods
     VNumRange& declRange() VL_MT_STABLE { return m_declRange; }
     const VNumRange& declRange() const VL_MT_STABLE { return m_declRange; }
-    void declRange(const VNumRange& flag) { m_declRange = flag; }
 };
 class AstSubstrN final : public AstNodeTriop {
     // Verilog string.substr()
diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h
index d9dc1976c..46bfef349 100644
--- a/src/V3AstNodeOther.h
+++ b/src/V3AstNodeOther.h
@@ -322,7 +322,6 @@ public:
     void level(int value) { m_level = value; }
     int level() const VL_MT_SAFE { return m_level; }
     string libname() const { return m_libname; }
-    string prettyLibnameQ() const { return "'" + prettyName(libname()) + "'"; }
     bool isTop() const VL_MT_SAFE { return level() == 1; }
     bool modPublic() const { return m_modPublic; }
     void modPublic(bool flag) { m_modPublic = flag; }
@@ -409,13 +408,12 @@ public:
     void text(const string& value) { m_text = value; }
 };
 class AstNodeSimpleText VL_NOT_FINAL : public AstNodeText {
-    bool m_tracking;  // When emit, it's ok to parse the string to do indentation
+    const bool m_tracking;  // When emit, it's ok to parse the string to do indentation
 public:
     AstNodeSimpleText(VNType t, FileLine* fl, const string& textp, bool tracking = false)
         : AstNodeText{t, fl, textp}
         , m_tracking{tracking} {}
     ASTGEN_MEMBERS_AstNodeSimpleText;
-    void tracking(bool flag) { m_tracking = flag; }
     bool tracking() const { return m_tracking; }
 };
 
@@ -725,14 +723,11 @@ class AstCellInline final : public AstNode {
     // @astgen ptr := m_scopep : Optional[AstScope]  // The scope that the cell is inlined into
     string m_name;  // Cell name, possibly {a}__DOT__{b}...
     const string m_origModName;  // Original name of module, ignoring name() changes, for LinkDot
-    VTimescale m_timeunit;  // Parent module time unit
 public:
-    AstCellInline(FileLine* fl, const string& name, const string& origModName,
-                  const VTimescale& timeunit)
+    AstCellInline(FileLine* fl, const string& name, const string& origModName)
         : ASTGEN_SUPER_CellInline(fl)
         , m_name{name}
-        , m_origModName{origModName}
-        , m_timeunit{timeunit} {}
+        , m_origModName{origModName} {}
     ASTGEN_MEMBERS_AstCellInline;
     void dump(std::ostream& str) const override;
     void dumpJson(std::ostream& str) const override;
@@ -741,8 +736,6 @@ public:
     bool maybePointedTo() const override VL_MT_SAFE { return true; }
     string origModName() const { return m_origModName; }  // * = modp()->origName() before inlining
     void name(const string& name) override { m_name = name; }
-    void timeunit(const VTimescale& flag) { m_timeunit = flag; }
-    VTimescale timeunit() const { return m_timeunit; }
 };
 class AstCellInlineScope final : public AstNode {
     // A particular scoped usage of a Cell Inline
@@ -770,7 +763,6 @@ public:
     string origModName() const {
         return m_cellp->origModName();
     }  // * = modp()->origName() before inlining
-    void scopep(AstScope* nodep) { m_scopep = nodep; }
 };
 class AstClassExtends final : public AstNode {
     // class extends class name, or class implements class name
@@ -943,7 +935,7 @@ public:
     explicit AstConstPool(FileLine* fl);
     ASTGEN_MEMBERS_AstConstPool;
     bool maybePointedTo() const override VL_MT_SAFE { return true; }
-    void cloneRelink() override { UASSERT(!clonep(), "Not cloneable"); }
+    void cloneRelink() override { V3ERROR_NA; }  // Not cloneable
     AstModule* modp() const { return m_modp; }
 
     // Find a table (unpacked array) within the constant pool which is initialized with the
@@ -1108,7 +1100,7 @@ public:
     explicit AstExecGraph(FileLine* fl, const string& name) VL_MT_DISABLED;
     ~AstExecGraph() override;
     ASTGEN_MEMBERS_AstExecGraph;
-    void cloneRelink() override { UASSERT(!clonep(), "Not cloneable"); }
+    void cloneRelink() override { V3ERROR_NA; }  // Not cloneable
     const char* broken() const override {
         BROKEN_RTN(!m_depGraphp);
         return nullptr;
@@ -1256,7 +1248,7 @@ class AstModportVarRef final : public AstNode {
     //
     // @astgen ptr := m_varp : Optional[AstVar]  // Link to the actual Var
     string m_name;  // Name of the variable referenced
-    VDirection m_direction;  // Direction of the variable (in/out)
+    const VDirection m_direction;  // Direction of the variable (in/out)
 public:
     AstModportVarRef(FileLine* fl, const string& name, VDirection::en direction)
         : ASTGEN_SUPER_ModportVarRef(fl)
@@ -1266,7 +1258,6 @@ public:
     void dump(std::ostream& str) const override;
     void dumpJson(std::ostream& str) const override;
     string name() const override VL_MT_STABLE { return m_name; }
-    void direction(const VDirection& flag) { m_direction = flag; }
     VDirection direction() const { return m_direction; }
     AstVar* varp() const VL_MT_STABLE { return m_varp; }  // [After Link] Pointer to variable
     void varp(AstVar* varp) { m_varp = varp; }
@@ -1297,7 +1288,7 @@ public:
     AstNetlist();
     ASTGEN_MEMBERS_AstNetlist;
     void deleteContents();
-    void cloneRelink() override { UASSERT(!clonep(), "Not cloneable"); }
+    void cloneRelink() override { V3ERROR_NA; }  // Not cloneable
     string name() const override VL_MT_STABLE { return "$root"; }
     void dump(std::ostream& str) const override;
     void dumpJson(std::ostream& str) const override;
@@ -1343,12 +1334,6 @@ class AstPackageExport final : public AstNode {
     string m_pkgName;  // Module the cell instances
 
 public:
-    AstPackageExport(FileLine* fl, AstPackage* packagep, const string& name)
-        : ASTGEN_SUPER_PackageExport(fl)
-        , m_name{name}
-        , m_packagep{packagep} {
-        pkgNameFrom();
-    }
     AstPackageExport(FileLine* fl, const string& pkgName, const string& name)
         : ASTGEN_SUPER_PackageExport(fl)
         , m_name{name}
@@ -1362,9 +1347,6 @@ public:
     string prettyPkgNameQ() const { return "'" + prettyName(pkgName()) + "'"; }
     AstPackage* packagep() const { return m_packagep; }
     void packagep(AstPackage* nodep) { m_packagep = nodep; }
-
-private:
-    void pkgNameFrom();
 };
 class AstPackageExportStarStar final : public AstNode {
     // A package export *::* declaration
@@ -1424,7 +1406,6 @@ public:
         , m_name{name} {
         this->exprp(exprp);
     }
-    inline AstPin(FileLine* fl, int pinNum, AstVarRef* varname, AstNode* exprp);
     ASTGEN_MEMBERS_AstPin;
     void cloneRelink() override {}  // TODO V3Param shouldn't require avoiding cloneRelinkGen
     void dump(std::ostream& str) const override;
@@ -1698,7 +1679,7 @@ public:
     explicit AstTypeTable(FileLine* fl);
     ASTGEN_MEMBERS_AstTypeTable;
     bool maybePointedTo() const override VL_MT_SAFE { return true; }
-    void cloneRelink() override { UASSERT(!clonep(), "Not cloneable"); }
+    void cloneRelink() override { V3ERROR_NA; }  // Not cloneable
     AstBasicDType* findBasicDType(FileLine* fl, VBasicDTypeKwd kwd);
     AstBasicDType* findLogicBitDType(FileLine* fl, VBasicDTypeKwd kwd, int width, int widthMin,
                                      VSigning numeric);
@@ -1863,7 +1844,6 @@ class AstVar final : public AstNode {
     bool m_primaryIO : 1;  // In/out to top level (or directly assigned from same)
     bool m_primaryClock : 1;  // In/out to top level and is, or combinationally drives a SenItem
     bool m_sc : 1;  // SystemC variable
-    bool m_scClocked : 1;  // SystemC sc_clk<> needed
     bool m_scSensitive : 1;  // SystemC sensitive() needed
     bool m_sigPublic : 1;  // User C code accesses this signal or is top signal
     bool m_sigModPublic : 1;  // User C code accesses this signal and module
@@ -1913,7 +1893,6 @@ class AstVar final : public AstNode {
         m_primaryIO = false;
         m_primaryClock = false;
         m_sc = false;
-        m_scClocked = false;
         m_scSensitive = false;
         m_usedParam = false;
         m_usedLoopIdx = false;
@@ -2052,7 +2031,6 @@ public:
     void declTyped(bool flag) { m_declTyped = flag; }
     void sensIfacep(AstIface* nodep) { m_sensIfacep = nodep; }
     void attrFileDescr(bool flag) { m_fileDescr = flag; }
-    void attrScClocked(bool flag) { m_scClocked = flag; }
     void attrScBv(bool flag) { m_attrScBv = flag; }
     void attrIsolateAssign(bool flag) { m_attrIsolateAssign = flag; }
     void attrSFormat(bool flag) { m_attrSFormat = flag; }
@@ -2195,7 +2173,6 @@ public:
     bool isPulldown() const { return m_isPulldown; }
     bool attrScBv() const { return m_attrScBv; }
     bool attrFileDescr() const { return m_fileDescr; }
-    bool attrScClocked() const { return m_scClocked; }
     bool attrSFormat() const { return m_attrSFormat; }
     bool attrSplitVar() const { return m_attrSplitVar; }
     bool attrIsolateAssign() const { return m_attrIsolateAssign; }
diff --git a/src/V3AstNodeStmt.h b/src/V3AstNodeStmt.h
index 38fd4adba..7b4d549dd 100644
--- a/src/V3AstNodeStmt.h
+++ b/src/V3AstNodeStmt.h
@@ -254,9 +254,7 @@ public:
         : ASTGEN_SUPER_Break(fl) {}
     ASTGEN_MEMBERS_AstBreak;
     string verilogKwd() const override { return "break"; }
-    bool isBrancher() const override {
-        return true;  // SPECIAL: We don't process code after breaks
-    }
+    bool isBrancher() const override { V3ERROR_NA_RETURN(true); }  // Node removed early
 };
 class AstCReset final : public AstNodeStmt {
     // Reset variable at startup
@@ -399,9 +397,7 @@ public:
         : ASTGEN_SUPER_Continue(fl) {}
     ASTGEN_MEMBERS_AstContinue;
     string verilogKwd() const override { return "continue"; }
-    bool isBrancher() const override {
-        return true;  // SPECIAL: We don't process code after breaks
-    }
+    bool isBrancher() const override { V3ERROR_NA_RETURN(true); }  // Node removed early
 };
 class AstCoverInc final : public AstNodeStmt {
     // Coverage analysis point; increment coverage count
@@ -485,9 +481,7 @@ public:
     void dump(std::ostream& str) const override;
     void targetp(AstNode* nodep) { m_targetp = nodep; }
     AstNode* targetp() const { return m_targetp; }
-    bool isBrancher() const override {
-        return true;  // SPECIAL: We don't process code after breaks
-    }
+    bool isBrancher() const override { V3ERROR_NA_RETURN(true); }  // Node removed early
 };
 class AstDisableFork final : public AstNodeStmt {
     // A "disable fork" statement
@@ -820,9 +814,7 @@ public:
     }
     ASTGEN_MEMBERS_AstReturn;
     string verilogKwd() const override { return "return"; }
-    bool isBrancher() const override {
-        return true;  // SPECIAL: We don't process code after breaks
-    }
+    bool isBrancher() const override { V3ERROR_NA_RETURN(true); }  // Node removed early
 };
 class AstSFormat final : public AstNodeStmt {
     // Parents: statement container
diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp
index 1705e31ea..270a8c44f 100644
--- a/src/V3AstNodes.cpp
+++ b/src/V3AstNodes.cpp
@@ -513,7 +513,6 @@ void AstVar::combineType(const AstVar* otherp) {
     if (otherp->isSigModPublic()) sigModPublic(true);
     if (otherp->isSigUserRdPublic()) sigUserRdPublic(true);
     if (otherp->isSigUserRWPublic()) sigUserRWPublic(true);
-    if (otherp->attrScClocked()) attrScClocked(true);
     if (otherp->varType() == VVarType::PORT) {
         varType(otherp->varType());
         direction(otherp->direction());
@@ -2203,8 +2202,6 @@ void AstPrintTimeScale::dumpJson(std::ostream& str) const {
     dumpJsonGen(str);
 }
 
-void AstNodeTermop::dump(std::ostream& str) const { this->AstNodeExpr::dump(str); }
-void AstNodeTermop::dumpJson(std::ostream& str) const { dumpJsonGen(str); }
 void AstTime::dump(std::ostream& str) const {
     this->AstNodeTermop::dump(str);
     str << " " << timeunit();
@@ -2479,9 +2476,6 @@ void AstPackageExport::dump(std::ostream& str) const {
     }
 }
 void AstPackageExport::dumpJson(std::ostream& str) const { dumpJsonGen(str); }
-void AstPackageExport::pkgNameFrom() {
-    if (packagep()) m_pkgName = packagep()->name();
-}
 void AstPackageImport::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (packagep()) {
@@ -2834,14 +2828,6 @@ void AstStrengthSpec::dumpJson(std::ostream& str) const {
     dumpJsonStr(str, "strength1", m_s1.ascii());
     dumpJsonGen(str);
 }
-void AstParseRef::dump(std::ostream& str) const {
-    this->AstNode::dump(str);
-    str << " [" << expect().ascii() << "]";
-}
-void AstParseRef::dumpJson(std::ostream& str) const {
-    dumpJsonStr(str, "expect", expect().ascii());
-    dumpJsonGen(str);
-}
 void AstClassOrPackageRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (classOrPackageNodep()) str << " cpkg=" << nodeAddr(classOrPackageNodep());
diff --git a/src/V3Begin.cpp b/src/V3Begin.cpp
index 5563f4b9a..21f3cdaad 100644
--- a/src/V3Begin.cpp
+++ b/src/V3Begin.cpp
@@ -91,7 +91,7 @@ class BeginVisitor final : public VNVisitor {
                 // Create CellInline for dotted var resolution
                 if (!m_ftaskp) {
                     AstCellInline* const inlinep
-                        = new AstCellInline{flp, m_unnamedScope, blockName, m_modp->timeunit()};
+                        = new AstCellInline{flp, m_unnamedScope, blockName};
                     m_modp->addInlinesp(inlinep);  // Must be parsed before any AstCells
                 }
             }
@@ -407,7 +407,7 @@ static AstNode* createForeachLoop(AstNodeForeach* nodep, AstNode* bodysp, AstVar
         condp = new AstGteS{fl, varRefp, rightp};
         inc = false;
         break;
-    default: UASSERT_OBJ(0, varp, "Missing comparison handling"); break;
+    default: varp->v3fatalSrc("Missing comparison handling"); break;
     }
     AstNodeExpr* incp;
     if (inc)
diff --git a/src/V3Control.cpp b/src/V3Control.cpp
index 220bc67aa..3043bfdd3 100644
--- a/src/V3Control.cpp
+++ b/src/V3Control.cpp
@@ -383,7 +383,7 @@ public:
         // allow old rules to still match using a final '*'
         string newMatch = match;
         if (newMatch.empty() || newMatch.back() != '*') newMatch += '*';
-        m_waivers.emplace_back(WaiverSetting{code, contents, newMatch});
+        m_waivers.emplace_back(code, contents, newMatch);
     }
 
     void applyBlock(AstGenBlock* nodep) {
diff --git a/src/V3Dfg.cpp b/src/V3Dfg.cpp
index 784fbf552..9c5db2b23 100644
--- a/src/V3Dfg.cpp
+++ b/src/V3Dfg.cpp
@@ -296,7 +296,7 @@ static void dumpDotVertex(std::ostream& os, const DfgVertex& vtx) {
         } else if (varVtxp->is<DfgVarArray>()) {
             os << ", shape=box3d";
         } else {
-            varVtxp->v3fatalSrc("Unhandled DfgVertexVar sub-type");  // LCOV_EXCL_LINE
+            varVtxp->v3fatalSrc("Unhandled DfgVertexVar sub-type");
         }
         // Color
         if (varp->direction() == VDirection::INPUT) {
diff --git a/src/V3Dfg.h b/src/V3Dfg.h
index 091b9ead5..fed302c0f 100644
--- a/src/V3Dfg.h
+++ b/src/V3Dfg.h
@@ -319,6 +319,7 @@ public:
     inline bool isCheaperThanLoad() const;
 
     // Methods that allow DfgVertex to participate in error reporting/messaging
+    // LCOV_EXCL_START
     void v3errorEnd(std::ostringstream& str) const VL_RELEASE(V3Error::s().m_mutex) {
         m_filelinep->v3errorEnd(str);
     }
@@ -332,6 +333,7 @@ public:
     string warnContextSecondary() const { return fileline()->warnContextSecondary(); }
     string warnMore() const VL_REQUIRES(V3Error::s().m_mutex) { return fileline()->warnMore(); }
     string warnOther() const VL_REQUIRES(V3Error::s().m_mutex) { return fileline()->warnOther(); }
+    // LCOV_EXCL_STOP
 
 private:
     // For internal use only.
diff --git a/src/V3DfgBreakCycles.cpp b/src/V3DfgBreakCycles.cpp
index 45ee24157..8f15bf405 100644
--- a/src/V3DfgBreakCycles.cpp
+++ b/src/V3DfgBreakCycles.cpp
@@ -1121,7 +1121,7 @@ class FixUpIndependentRanges final {
         if (const DfgVertexVar* const varp = vtx.cast<DfgVertexVar>()) {
             return varp->nodep()->name();
         }
-        vtx.v3fatalSrc("Unhandled node type");  // LCOV_EXCL_LINE
+        vtx.v3fatalSrc("Unhandled node type");
     }
 
     // Trace drivers of independent bits of 'vtxp' in the range '[hi:lo]'
diff --git a/src/V3DfgCse.cpp b/src/V3DfgCse.cpp
index f1eb3d8db..f7e568c19 100644
--- a/src/V3DfgCse.cpp
+++ b/src/V3DfgCse.cpp
@@ -46,13 +46,15 @@ class V3DfgCse final {
     static V3Hash vertexSelfHash(const DfgVertex& vtx) {
         switch (vtx.type()) {
         // Unhandled vertices
-        case VDfgType::Logic:
-        case VDfgType::Unresolved: vtx.v3fatalSrc("Should not have reached CSE");
+        case VDfgType::Logic:  // LCOV_EXCL_LINE
+        case VDfgType::Unresolved:  // LCOV_EXCL_STOP
+            vtx.v3fatalSrc("Should not have reached CSE");
 
         // Special vertices
-        case VDfgType::Const:
+        case VDfgType::Const:  // LCOV_EXCL_START
         case VDfgType::VarArray:
-        case VDfgType::VarPacked: vtx.v3fatalSrc("Hash should have been pre-computed");
+        case VDfgType::VarPacked:  // LCOV_EXCL_STOP
+            vtx.v3fatalSrc("Hash should have been pre-computed");
 
         // Vertices with internal information
         case VDfgType::Sel: return V3Hash{vtx.as<DfgSel>()->lsb()};
@@ -155,8 +157,9 @@ class V3DfgCse final {
         // by 'vertexEquivalent'.
         switch (a.type()) {
         // Unhandled vertices
-        case VDfgType::Logic:
-        case VDfgType::Unresolved: a.v3fatalSrc("Should not have reached CSE");
+        case VDfgType::Logic:  // LCOV_EXCL_START
+        case VDfgType::Unresolved:  // LCOV_EXCL_STOP
+            a.v3fatalSrc("Should not have reached CSE");
 
         // Special vertices
         case VDfgType::Const: return a.as<DfgConst>()->num().isCaseEq(b.as<DfgConst>()->num());
diff --git a/src/V3DfgDataType.h b/src/V3DfgDataType.h
index 4a84f576c..e103b8f9f 100644
--- a/src/V3DfgDataType.h
+++ b/src/V3DfgDataType.h
@@ -168,9 +168,7 @@ public:
             UASSERT(lo + size - 1 < dtype.size(), "Out of range");
             return DfgDataType::array(dtype.elemDtype(), size);
         }
-        case Kind::Null: {
-            UASSERT(false, "Type cannot be selected from");
-        }
+        case Kind::Null: v3fatal("Type cannot be selected from");  // LCOV_EXCL_LINE
         }
         VL_UNREACHABLE;
     }
diff --git a/src/V3DfgSynthesize.cpp b/src/V3DfgSynthesize.cpp
index f7bf3b295..ae5c12ed5 100644
--- a/src/V3DfgSynthesize.cpp
+++ b/src/V3DfgSynthesize.cpp
@@ -170,7 +170,7 @@ class AstToDfgConverter final : public VNVisitor {
                 } else if (newp->is<DfgVarArray>()) {
                     newp->srcp(make<DfgSpliceArray>(newp->fileline(), newp->dtype()));
                 } else {
-                    nodep->v3fatalSrc("Unhandled DfgVertexVar sub-type");  // LCOV_EXCL_LINE
+                    nodep->v3fatalSrc("Unhandled DfgVertexVar sub-type");
                 }
 
                 // Use new temporary
@@ -245,7 +245,7 @@ class AstToDfgConverter final : public VNVisitor {
                     DfgSpliceArray* const newp = make<DfgSpliceArray>(flp, dtype);
                     splicep->addDriver(newp, index, flp);
                 } else {
-                    nodep->v3fatalSrc("Unhandled data type kind");  // LCOV_EXCL_LINE
+                    nodep->v3fatalSrc("Unhandled data type kind");
                 }
             }
 
@@ -345,7 +345,7 @@ class AstToDfgConverter final : public VNVisitor {
                     sap->addDriver(item.m_rhsp, item.m_idx, flp);
                 }
             } else {
-                item.m_lhsp->v3fatalSrc("Unhandled DfgVertexSplice sub-type");  // LCOV_EXCL_LINE
+                item.m_lhsp->v3fatalSrc("Unhandled DfgVertexSplice sub-type");
             }
         }
 
@@ -894,7 +894,7 @@ class AstToDfgSynthesize final {
         } else if (var.is<DfgVarArray>()) {
             splicep = make<DfgSpliceArray>(var.fileline(), var.dtype());
         } else {
-            var.v3fatalSrc("Unhandled DfgVertexVar sub-type");  // LCOV_EXCL_LINE
+            var.v3fatalSrc("Unhandled DfgVertexVar sub-type");
         }
         for (const Driver& d : newDrivers) splicep->addDriver(d.m_vtxp, d.m_lo, d.m_flp);
         return splicep;
diff --git a/src/V3EmitCBase.cpp b/src/V3EmitCBase.cpp
index 166955a2d..739c607aa 100644
--- a/src/V3EmitCBase.cpp
+++ b/src/V3EmitCBase.cpp
@@ -193,21 +193,17 @@ void EmitCBaseVisitorConst::emitVarDecl(const AstVar* nodep, bool asRef) {
 
     if (nodep->isIO() && nodep->isSc()) {
         UASSERT_OBJ(basicp, nodep, "Unimplemented: Outputting this data type");
-        if (nodep->attrScClocked() && nodep->isReadOnly()) {
-            putns(nodep, "sc_core::sc_in_clk ");
+        if (nodep->isInout()) {
+            putns(nodep, "sc_core::sc_inout<");
+        } else if (nodep->isWritable()) {
+            putns(nodep, "sc_core::sc_out<");
+        } else if (nodep->isNonOutput()) {
+            putns(nodep, "sc_core::sc_in<");
         } else {
-            if (nodep->isInout()) {
-                putns(nodep, "sc_core::sc_inout<");
-            } else if (nodep->isWritable()) {
-                putns(nodep, "sc_core::sc_out<");
-            } else if (nodep->isNonOutput()) {
-                putns(nodep, "sc_core::sc_in<");
-            } else {
-                nodep->v3fatalSrc("Unknown type");
-            }
-            puts(nodep->scType());
-            puts("> ");
+            nodep->v3fatalSrc("Unknown type");
         }
+        puts(nodep->scType());
+        puts("> ");
         if (asRef) {
             if (refNeedParens) putns(nodep, "(");
             putns(nodep, "&");
diff --git a/src/V3EmitCFunc.cpp b/src/V3EmitCFunc.cpp
index 9c4e8731a..717cd83de 100644
--- a/src/V3EmitCFunc.cpp
+++ b/src/V3EmitCFunc.cpp
@@ -247,12 +247,11 @@ void EmitCFunc::displayArg(AstNode* dispp, AstNode** elistp, bool isScan, const
     AstNode* argp = nullptr;
     if (!ignore) {
         argp = *elistp;
-        if (VL_UNCOVERABLE(!argp)) {
+        if (VL_UNCOVERABLE(!argp)) {  // LCOV_EXCL_START
             // expectDisplay() checks this first, so internal error if found here
-            dispp->v3error(
-                "Internal: Missing arguments for $display-like format");  // LCOV_EXCL_LINE
-            return;  // LCOV_EXCL_LINE
-        }
+            dispp->v3error("Internal: Missing arguments for $display-like format");
+            return;
+        }  // LCOV_EXCL_STOP
         // Prep for next parameter
         *elistp = (*elistp)->nextp();
         if (argp->widthMin() > VL_VALUE_STRING_MAX_WIDTH) {
diff --git a/src/V3EmitCMake.cpp b/src/V3EmitCMake.cpp
index 294151bd9..e45864ead 100644
--- a/src/V3EmitCMake.cpp
+++ b/src/V3EmitCMake.cpp
@@ -26,6 +26,8 @@
 
 VL_DEFINE_DEBUG_FUNCTIONS;
 
+// TODO: this file is completely uncovered by tests
+
 // ######################################################################
 //  Emit statements
 
diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp
index fc6380fbd..891241651 100644
--- a/src/V3EmitCSyms.cpp
+++ b/src/V3EmitCSyms.cpp
@@ -367,10 +367,6 @@ class EmitCSyms final : EmitCBaseVisitorConst {
         if ((nodep->isSigUserRdPublic() || nodep->isSigUserRWPublic()) && !m_cfuncp)
             m_modVars.emplace_back(m_modp, nodep);
     }
-    void visit(AstVarScope* nodep) override {
-        iterateChildrenConst(nodep);
-        m_statVarScopeBytes += nodep->varp()->dtypep()->widthTotalBytes();
-    }
     void visit(AstNodeCoverDecl* nodep) override {
         // Assign numbers to all bins, so we know how big of an array to use
         if (!nodep->dataDeclNullp()) {  // else duplicate we don't need code for
@@ -830,6 +826,7 @@ void EmitCSyms::emitSymImp() {
         if (v3Global.opt.debugStackCheck()) stackSize += 1024 * 1024 * 1024;
         V3Stats::addStat("Size prediction, Stack (bytes)", stackSize);
         puts("Verilated::stackCheck(" + cvtToStr(stackSize) + ");\n");
+        // TODO: 'm_statVarScopeBytes' is always 0, AstVarScope doesn't reach here (V3Descope)
         V3Stats::addStat("Size prediction, Heap, from Var Scopes (bytes)", m_statVarScopeBytes);
         V3Stats::addStat(V3Stats::STAT_MODEL_SIZE, stackSize + m_statVarScopeBytes);
     }
diff --git a/src/V3Error.cpp b/src/V3Error.cpp
index 58764db7d..fcf50b371 100644
--- a/src/V3Error.cpp
+++ b/src/V3Error.cpp
@@ -104,7 +104,7 @@ void V3ErrorGuarded::vlAbortOrExit() VL_REQUIRES(m_mutex) {
         VL_GCOV_DUMP();
         // Exit without triggering any global destructors. Used to prevent
         // detached V3ThreadPool jobs accessing destroyed static objects.
-        ::_exit(1);
+        ::_exit(1);  // LCOV_EXCL_LINE
     }
     v3Global.vlExit(1);
 #else
@@ -375,7 +375,7 @@ void V3Error::vlAbort() {
     v3Global.shutdown();
 #endif
     VL_GCOV_DUMP();
-    std::abort();
+    std::abort();  // LCOV_EXCL_LINE
 }
 std::ostringstream& V3Error::v3errorPrep(V3ErrorCode code) VL_ACQUIRE(s().m_mutex) {
     V3Error::s().m_mutex.lock();
diff --git a/src/V3File.h b/src/V3File.h
index 56d808efb..9ed5523d8 100644
--- a/src/V3File.h
+++ b/src/V3File.h
@@ -133,8 +133,6 @@ public:
     V3OutFormatter(Language lang);
     virtual ~V3OutFormatter() = default;
     // ACCESSORS
-    int column() const { return m_column; }
-    int blockIndent() const { return m_blockIndent; }
     void blockIndent(int flag) { m_blockIndent = flag; }
     // METHODS
     void printf(const char* fmt...) VL_ATTR_PRINTF(2);
diff --git a/src/V3Graph.cpp b/src/V3Graph.cpp
index ced3a7d26..1daa00c2b 100644
--- a/src/V3Graph.cpp
+++ b/src/V3Graph.cpp
@@ -105,7 +105,7 @@ template V3GraphEdge* V3GraphVertex::findConnectingEdgep<GraphWay::FORWARD>(V3Gr
 template V3GraphEdge* V3GraphVertex::findConnectingEdgep<GraphWay::REVERSE>(V3GraphVertex*);
 
 // cppcheck-has-bug-suppress constParameter
-void V3GraphVertex::v3errorEnd(const std::ostringstream& str) const
+void V3GraphVertex::v3errorEnd(const std::ostringstream& str) const  // LCOV_EXCL_START
     VL_RELEASE(V3Error::s().m_mutex) {
     std::ostringstream nsstr;
     nsstr << str.str();
@@ -119,9 +119,9 @@ void V3GraphVertex::v3errorEnd(const std::ostringstream& str) const
 void V3GraphVertex::v3errorEndFatal(const std::ostringstream& str) const
     VL_RELEASE(V3Error::s().m_mutex) {
     v3errorEnd(str);
-    assert(0);  // LCOV_EXCL_LINE
+    assert(0);
     VL_UNREACHABLE;
-}
+}  // LCOV_EXCL_STOP
 
 std::ostream& operator<<(std::ostream& os, V3GraphVertex* vertexp) {
     os << "  VERTEX=" << vertexp->name();
diff --git a/src/V3Hasher.cpp b/src/V3Hasher.cpp
index 8a60ef83b..38a9c5b67 100644
--- a/src/V3Hasher.cpp
+++ b/src/V3Hasher.cpp
@@ -359,8 +359,7 @@ class HasherVisitor final : public VNVisitorConst {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, []() {});
     }
     void visit(AstParseRef* nodep) override {
-        m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [this, nodep]() {
-            m_hash += nodep->expect();
+        m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [this, nodep]() {  //
             m_hash += nodep->name();
         });
     }
diff --git a/src/V3HierBlock.h b/src/V3HierBlock.h
index c02240dab..ddee89738 100644
--- a/src/V3HierBlock.h
+++ b/src/V3HierBlock.h
@@ -51,8 +51,6 @@ public:
 
     const GParams& gparams() const { return m_params; };
     const GTypeParams& gTypeParams() const { return m_typeParams; };
-    GParams& gparams() { return m_params; };
-    GTypeParams& gTypeParams() { return m_typeParams; };
 
     void swap(V3HierBlockParams& other) {
         m_params.swap(other.m_params);
diff --git a/src/V3Inline.cpp b/src/V3Inline.cpp
index b269d5885..d4caac315 100644
--- a/src/V3Inline.cpp
+++ b/src/V3Inline.cpp
@@ -520,7 +520,7 @@ void connectPort(AstNodeModule* modp, AstVar* nodep, AstNodeExpr* pinExprp) {
     } else if (nodep->direction() == VDirection::OUTPUT) {
         modp->addStmtsp(new AstAssignW{flp, pinRef(VAccess::WRITE), portRef(VAccess::READ)});
     } else {
-        pinExprp->v3fatalSrc("V3Tristate left INOUT port");  // LCOV_EXCL_LINE
+        pinExprp->v3fatalSrc("V3Tristate left INOUT port");
     }
 }
 
@@ -555,8 +555,8 @@ void inlineCell(AstNodeModule* modp, AstCell* cellp, bool last) {
     }
 
     // Create data for resolving hierarchical references later.
-    modp->addInlinesp(new AstCellInline{cellp->fileline(), cellp->name(),
-                                        cellp->modp()->origName(), cellp->modp()->timeunit()});
+    modp->addInlinesp(
+        new AstCellInline{cellp->fileline(), cellp->name(), cellp->modp()->origName()});
 
     // Connect the pins on the instance
     for (AstPin* pinp = cellp->pinsp(); pinp; pinp = VN_AS(pinp->nextp(), Pin)) {
diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp
index a434f8448..d2d1fa200 100644
--- a/src/V3LinkCells.cpp
+++ b/src/V3LinkCells.cpp
@@ -470,10 +470,10 @@ class LinkCellsVisitor final : public VNVisitor {
                         if (pinStar) {
                             UINFO(9, "    need .* PORT  " << portp);
                             // Create any not already connected
-                            AstPin* const newp = new AstPin{
-                                nodep->fileline(), 0, portp->name(),
-                                new AstParseRef{nodep->fileline(), VParseRefExp::PX_TEXT,
-                                                portp->name(), nullptr, nullptr}};
+                            AstPin* const newp
+                                = new AstPin{nodep->fileline(), 0, portp->name(),
+                                             new AstParseRef{nodep->fileline(), portp->name(),
+                                                             nullptr, nullptr}};
                             newp->svDotName(true);
                             newp->svImplicit(true);
                             nodep->addPinsp(newp);
diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp
index 90808479e..ef3a12cb6 100644
--- a/src/V3LinkDot.cpp
+++ b/src/V3LinkDot.cpp
@@ -541,9 +541,9 @@ public:
                 continue;
             } else if (ifacerefp->ifaceViaCellp()->dead()
                        || !existsNodeSym(ifacerefp->ifaceViaCellp())) {
-                UASSERT_OBJ(false, ifacerefp->ifaceViaCellp(),
-                            "Interface referenced by virtual iface is dead. "
-                            "Dead interfaces have required linking steps skipped");
+                ifacerefp->ifaceViaCellp()->v3fatalSrc(
+                    "Interface referenced by virtual iface is dead. "
+                    "Dead interfaces have required linking steps skipped");
             }
             VSymEnt* const ifaceSymp = getNodeSym(ifacerefp->ifaceViaCellp());
             VSymEnt* ifOrPortSymp = ifaceSymp;
@@ -2664,8 +2664,7 @@ class LinkDotResolveVisitor final : public VNVisitor {
         if (classExtendsp->argsp()) pinsp = classExtendsp->argsp()->cloneTree(true);
         AstNew* const newExprp = new AstNew{fl, pinsp};
         newExprp->isImplicit(true);
-        AstDot* const superNewp
-            = new AstDot{fl, false, new AstParseRef{fl, VParseRefExp::PX_ROOT, "super"}, newExprp};
+        AstDot* const superNewp = new AstDot{fl, false, new AstParseRef{fl, "super"}, newExprp};
         AstNodeStmt* const superNewStmtp = superNewp->makeStmt();
         for (AstNode* stmtp = nodep->stmtsp(); stmtp; stmtp = stmtp->nextp()) {
             // super.new shall be the first statement (IEEE 1800-2023 8.15)
@@ -3510,7 +3509,7 @@ class LinkDotResolveVisitor final : public VNVisitor {
                 allowVar = true;
             } else {
                 UINFO(1, "ds=" << m_ds.ascii());
-                nodep->v3fatalSrc("Unhandled VParseRefExp");
+                nodep->v3fatalSrc("Unhandled DotPosition");
             }
             // Lookup
             VSymEnt* foundp;
diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp
index e01e85fea..32850290d 100644
--- a/src/V3LinkParse.cpp
+++ b/src/V3LinkParse.cpp
@@ -397,9 +397,9 @@ class LinkParseVisitor final : public VNVisitor {
                 newfl->warnOff(V3ErrorCode::E_CONSTWRITTEN, true);
                 // Create a ParseRef to the wire. We cannot use the var as it may be deleted if
                 // it's a port (see t_var_set_link.v)
-                AstAssign* const assp = new AstAssign{
-                    newfl, new AstParseRef{newfl, VParseRefExp::PX_TEXT, nodep->name()},
-                    VN_AS(nodep->valuep()->unlinkFrBack(), NodeExpr)};
+                AstAssign* const assp
+                    = new AstAssign{newfl, new AstParseRef{newfl, nodep->name()},
+                                    VN_AS(nodep->valuep()->unlinkFrBack(), NodeExpr)};
                 if (nodep->lifetime().isAutomatic()) {
                     nodep->addNextHere(new AstInitialAutomatic{newfl, assp});
                 } else {
diff --git a/src/V3Mutex.h b/src/V3Mutex.h
index 892a596c3..9c341545e 100644
--- a/src/V3Mutex.h
+++ b/src/V3Mutex.h
@@ -54,7 +54,7 @@ class V3MutexConfig final {
 
 public:
     static V3MutexConfig& s() VL_MT_SAFE {
-        static V3MutexConfig s;
+        static V3MutexConfig s{};
         return s;
     }
 
@@ -67,7 +67,7 @@ public:
             // requires <iostream>
             // avoided to reduce compile time
             // std::cerr << "%Error: V3Mutex already configured." << std::endl;
-            std::abort();
+            std::abort();  // LCOV_EXCL_LINE
         }
     }
     bool lockConfig() VL_MT_SAFE { return m_lockConfig; }
diff --git a/src/V3Number.cpp b/src/V3Number.cpp
index ba202ca1e..8ac571c58 100644
--- a/src/V3Number.cpp
+++ b/src/V3Number.cpp
@@ -873,9 +873,7 @@ string V3Number::displayed(FileLine* fl, const string& vformat) const VL_MT_STAB
         str = displayPad(fmtsizen, ' ', left, toString());
         return str;
     }
-    default:
-        fl->v3fatalSrc("Unknown $display-like format code for number: %" << pos[0]);
-        return "ERR";
+    default: fl->v3fatalSrc("Unknown $display-like format code for number: %" << pos[0]);
     }
 }
 
diff --git a/src/V3Number.h b/src/V3Number.h
index 6c952a12b..6d8992b6b 100644
--- a/src/V3Number.h
+++ b/src/V3Number.h
@@ -69,9 +69,9 @@ private:
     // CONSTANTS
     // At least 2 words (64 fourstate bits). 4 words (128 fourstate bits) in most cases,
     // i.e. when std::string has 32 bytes.
-    static constexpr int INLINE_WORDS = vlstd::max(
-        static_cast<size_t>(2), vlstd::max(sizeof(std::string) / sizeof(ValueAndX),
-                                           sizeof(std::vector<ValueAndX>) / sizeof(ValueAndX)));
+    static constexpr int INLINE_WORDS = std::max(
+        static_cast<size_t>(2), std::max(sizeof(std::string) / sizeof(ValueAndX),
+                                         sizeof(std::vector<ValueAndX>) / sizeof(ValueAndX)));
     // When m_width > MAX_INLINE_WIDTH number is stored in m_dynamicNumber.
     // Otherwise number is stored in m_inlineNumber.
     static constexpr int MAX_INLINE_WIDTH = INLINE_WORDS * sizeof(ValueAndX) / 2 * 8;
diff --git a/src/V3Options.h b/src/V3Options.h
index ee3096f0f..3f06a9b5d 100644
--- a/src/V3Options.h
+++ b/src/V3Options.h
@@ -354,7 +354,6 @@ private:
     string      m_buildDepBin;  // main switch: --build-dep-bin {filename}
     string      m_diagnosticsSarifOutput;  // main switch: --diagnostics-sarif-output
     string      m_exeName;      // main switch: -o {name}
-    string      m_flags;        // main switch: -f {name}
     VFileLibList m_hierParamsFile; // main switch: --hierarchical-params-file
     string      m_jsonOnlyOutput;    // main switch: --json-only-output
     string      m_jsonOnlyMetaOutput;    // main switch: --json-only-meta-output
@@ -479,7 +478,6 @@ public:
     bool preprocResolve() const { return m_preprocResolve; }
     int preprocTokenLimit() const { return m_preprocTokenLimit; }
     bool underlineZero() const { return m_underlineZero; }
-    string flags() const { return m_flags; }
     bool systemC() const VL_MT_SAFE { return m_systemC; }
     bool savable() const VL_MT_SAFE { return m_savable; }
     bool stats() const { return m_stats; }
@@ -492,7 +490,6 @@ public:
     bool autoflush() const { return m_autoflush; }
     bool bboxSys() const { return m_bboxSys; }
     bool bboxUnsup() const { return m_bboxUnsup; }
-    bool binary() const { return m_binary; }
     bool build() const { return m_build; }
     string buildDepBin() const { return m_buildDepBin; }
     void buildDepBin(const string& flag) { m_buildDepBin = flag; }
@@ -622,9 +619,6 @@ public:
         return trace() && traceEnabledVcd() && (threads() > 1 || hierChild() > 1);
     }
     bool useFstWriterThread() const { return traceThreads() && traceEnabledFst(); }
-    unsigned vmTraceThreads() const {
-        return useTraceParallel() ? threads() : useTraceOffload() ? 1 : 0;
-    }
     int unrollCount() const { return m_unrollCount; }
     int unrollCountAdjusted(const VOptionBool& full, bool generate, bool simulate);
     int unrollStmts() const { return m_unrollStmts; }
diff --git a/src/V3Order.h b/src/V3Order.h
index d3b27a7d4..7027864d8 100644
--- a/src/V3Order.h
+++ b/src/V3Order.h
@@ -43,15 +43,13 @@ using ExternalDomainsProvider = std::function<void(const AstVarScope*, std::vect
 // Map from Trigger Sensitivity tree to original Sensitivity tree
 using TrigToSenMap = std::unordered_map<const AstSenTree*, const AstSenTree*>;
 
-AstCFunc* order(
-    AstNetlist* netlistp,  //
-    const std::vector<V3Sched::LogicByScope*>& logic,  //
-    const TrigToSenMap& trigToSen,  //
-    const string& tag,  //
-    bool parallel,  //
-    bool slow,  //
-    const ExternalDomainsProvider& externalDomains
-    = [](const AstVarScope*, std::vector<AstSenTree*>&) {}) VL_MT_DISABLED;
+AstCFunc* order(AstNetlist* netlistp,  //
+                const std::vector<V3Sched::LogicByScope*>& logic,  //
+                const TrigToSenMap& trigToSen,  //
+                const string& tag,  //
+                bool parallel,  //
+                bool slow,  //
+                const ExternalDomainsProvider& externalDomains) VL_MT_DISABLED;
 
 void selfTestParallel();
 
diff --git a/src/V3OrderGraphBuilder.cpp b/src/V3OrderGraphBuilder.cpp
index 6a291baa7..190e0a45e 100644
--- a/src/V3OrderGraphBuilder.cpp
+++ b/src/V3OrderGraphBuilder.cpp
@@ -337,11 +337,11 @@ class OrderGraphBuilder final : public VNVisitor {
 
     //--- Ignored nodes
     void visit(AstVar*) override {}
-    void visit(AstVarScope* nodep) override {}
-    void visit(AstCell*) override {}  // Only interested in the respective AstScope
-    void visit(AstTypeTable*) override {}
-    void visit(AstConstPool*) override {}
-    void visit(AstClass*) override {}
+    void visit(AstVarScope* nodep) override { nodep->v3fatalSrc("Should not reach V3Order"); }
+    void visit(AstCell* nodep) override { nodep->v3fatalSrc("Should not reach V3Order"); }
+    void visit(AstTypeTable* nodep) override { nodep->v3fatalSrc("Should not reach V3Order"); }
+    void visit(AstConstPool* nodep) override { nodep->v3fatalSrc("Should not reach V3Order"); }
+    void visit(AstClass* nodep) override { nodep->v3fatalSrc("Should not reach V3Order"); }
     void visit(AstCFunc*) override {
         // Calls to DPI exports handled with AstCCall. /* verilator public */ functions are
         // ignored for now (and hence potentially mis-ordered), but could use the same or
diff --git a/src/V3Os.cpp b/src/V3Os.cpp
index 13be637a4..f81da2c77 100644
--- a/src/V3Os.cpp
+++ b/src/V3Os.cpp
@@ -489,7 +489,7 @@ int V3Os::system(const string& command) {
     const int ret = ::system(command.c_str());
     if (VL_UNCOVERABLE(ret == -1)) {
         v3fatal("Failed to execute command:"  // LCOV_EXCL_LINE
-                << command << " " << std::strerror(errno));
+                << command << " " << std::strerror(errno));  // LCOV_EXCL_LINE
         return -1;  // LCOV_EXCL_LINE
     } else {
         UASSERT(WIFEXITED(ret), "system(" << command << ") returned unexpected value of " << ret);
diff --git a/src/V3ParseGrammar.cpp b/src/V3ParseGrammar.cpp
index 51d4821f6..d6582fc8d 100644
--- a/src/V3ParseGrammar.cpp
+++ b/src/V3ParseGrammar.cpp
@@ -97,10 +97,9 @@ AstArg* V3ParseGrammar::argWrapList(AstNodeExpr* nodep) {
 }
 
 AstNode* V3ParseGrammar::createSupplyExpr(FileLine* fileline, const string& name, int value) {
-    AstAssignW* assignp
-        = new AstAssignW{fileline, new AstParseRef{fileline, VParseRefExp::PX_TEXT, name},
-                         value ? new AstConst{fileline, AstConst::All1{}}
-                               : new AstConst{fileline, AstConst::All0{}}};
+    AstAssignW* assignp = new AstAssignW{fileline, new AstParseRef{fileline, name},
+                                         value ? new AstConst{fileline, AstConst::All1{}}
+                                               : new AstConst{fileline, AstConst::All0{}}};
     AstStrengthSpec* strengthSpecp
         = new AstStrengthSpec{fileline, VStrength::SUPPLY, VStrength::SUPPLY};
     assignp->strengthSpecp(strengthSpecp);
diff --git a/src/V3ParseGrammar.h b/src/V3ParseGrammar.h
index fc1f8239c..3f55f8c67 100644
--- a/src/V3ParseGrammar.h
+++ b/src/V3ParseGrammar.h
@@ -177,7 +177,7 @@ public:
         return new AstSenTree{fl, new AstSenItem{fl, VEdgeType::ET_COMBO_STAR, nullptr}};
     }
     AstNodeExpr* createGlobalClockParseRef(FileLine* fl) {
-        return new AstParseRef{fl, VParseRefExp::PX_TEXT, "__024global_clock", nullptr, nullptr};
+        return new AstParseRef{fl, "__024global_clock", nullptr, nullptr};
     }
     AstSenTree* createGlobalClockSenTree(FileLine* fl) {
         return createSenTreeChanged(fl, createGlobalClockParseRef(fl));
diff --git a/src/V3PreProc.cpp b/src/V3PreProc.cpp
index 443003fcb..920977687 100644
--- a/src/V3PreProc.cpp
+++ b/src/V3PreProc.cpp
@@ -1329,8 +1329,7 @@ int V3PreProcImp::getStateToken() {
                     define(fileline(), m_lastSym, value, formals, false);
                 }
             } else {
-                const string msg = "Bad define text, unexpected "s + tokenName(tok) + "\n";
-                v3fatalSrc(msg);
+                v3fatalSrc("Bad define text, unexpected "s + tokenName(tok) + "\n");
             }
             statePop();
             // DEFVALUE is terminated by a return, but lex can't return both tokens.
diff --git a/src/V3Slice.cpp b/src/V3Slice.cpp
index 151f69dfd..50e763f97 100644
--- a/src/V3Slice.cpp
+++ b/src/V3Slice.cpp
@@ -316,7 +316,9 @@ class SliceVisitor final : public VNVisitor {
                     "Array initialization should have been removed earlier");
     }
 
-    void expandBiOp(AstNodeBiop* nodep) {
+    template <typename T_NodeBiop>
+    void expandBiOp(T_NodeBiop* biopp) {
+        AstNodeBiop* nodep = biopp;
         if (nodep->user1SetOnce()) return;  // Process once
         UINFO(9, "  Bi-Eq/Neq expansion " << nodep);
 
@@ -330,10 +332,9 @@ class SliceVisitor final : public VNVisitor {
                 // EQ(a,b) -> LOGAND(EQ(ARRAYSEL(a,0), ARRAYSEL(b,0)), ...[1])
                 // Original node is replaced, so it is safe to copy it one time even if it is
                 // impure.
-                AstNodeBiop* const clonep = VN_AS(
-                    nodep->cloneType(cloneAndSel(nodep->lhsp(), elements, elemIdx, elemIdx != 0),
-                                     cloneAndSel(nodep->rhsp(), elements, elemIdx, elemIdx != 0)),
-                    NodeBiop);
+                T_NodeBiop* const clonep = new T_NodeBiop{
+                    nodep->fileline(), cloneAndSel(nodep->lhsp(), elements, elemIdx, elemIdx != 0),
+                    cloneAndSel(nodep->rhsp(), elements, elemIdx, elemIdx != 0)};
                 if (elemIdx == 0) {
                     nodep->foreach([this](AstExprStmt* const exprp) {
                         // Result expression is always evaluated to the same value, so the
diff --git a/src/V3StdFuture.h b/src/V3StdFuture.h
index 67736d885..329627461 100644
--- a/src/V3StdFuture.h
+++ b/src/V3StdFuture.h
@@ -21,12 +21,6 @@
 
 namespace vlstd {
 
-// constexpr std::max with arguments passed by value (required by constexpr before C++14)
-template <typename T>
-constexpr T max(T a, T b) {
-    return a > b ? a : b;
-}
-
 // C++17 is_invocable
 template <typename F, typename... Args>
 struct is_invocable
diff --git a/src/V3String.h b/src/V3String.h
index b073b3e6a..54b1ce1fc 100644
--- a/src/V3String.h
+++ b/src/V3String.h
@@ -58,22 +58,6 @@ typename std::enable_if<std::is_integral<T>::value, std::string>::type cvtToHex(
     return os.str();
 }
 
-inline uint32_t cvtToHash(const void* vp) {
-    // We can shove a 64 bit pointer into a 32 bit bucket
-    // On 32-bit systems, lower is always 0, but who cares?
-    union {
-        const void* up;
-        struct {
-            uint32_t upper;
-            uint32_t lower;
-        } l;
-    } u;
-    u.l.upper = 0;
-    u.l.lower = 0;
-    u.up = vp;
-    return u.l.upper ^ u.l.lower;
-}
-
 inline string ucfirst(const string& text) {
     string result = text;
     result[0] = std::toupper(result[0]);
diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp
index c0c9627bb..635ca473a 100644
--- a/src/V3TraceDecl.cpp
+++ b/src/V3TraceDecl.cpp
@@ -344,10 +344,10 @@ class TraceDeclVisitor final : public VNVisitor {
     void checkCalls(const AstCFunc* funcp) {
         if (!v3Global.opt.debugCheck()) return;
         checkCallsRecurse(funcp);
-        if (!m_declUncalledps.empty()) {
+        if (!m_declUncalledps.empty()) {  // LCOV_EXCL_START
             for (auto tracep : m_declUncalledps) UINFO(0, "-nodep " << tracep);
             (*(m_declUncalledps.begin()))->v3fatalSrc("Created TraceDecl which is never called");
-        }
+        }  // LCOV_EXCL_STOP
     }
     void checkCallsRecurse(const AstCFunc* funcp) {
         funcp->foreach([this](const AstNode* nodep) {
diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp
index 1aaff7580..75e646520 100644
--- a/src/V3Undriven.cpp
+++ b/src/V3Undriven.cpp
@@ -547,8 +547,8 @@ class UndrivenVisitor final : public VNVisitorConst {
     void visit(AstNodeCoverDecl*) override {}
     void visit(AstCoverInc*) override {}
     void visit(AstCoverToggle*) override {}
-    void visit(AstTraceDecl*) override {}
-    void visit(AstTraceInc*) override {}
+    void visit(AstTraceDecl* nodep) override { nodep->v3fatalSrc("Should not exist yet"); }
+    void visit(AstTraceInc* nodep) override { nodep->v3fatalSrc("Should not exist yet"); }
 
     // iterate
     void visit(AstConst* nodep) override {}
diff --git a/src/V3Width.cpp b/src/V3Width.cpp
index 3cbf67edc..8ed305187 100644
--- a/src/V3Width.cpp
+++ b/src/V3Width.cpp
@@ -5487,11 +5487,7 @@ class WidthVisitor final : public VNVisitor {
         assertAtStatement(nodep);
         iterateCheckBool(nodep, "Loop Condition", nodep->condp(), BOTH);
     }
-    void visit(AstRepeat* nodep) override {
-        assertAtStatement(nodep);
-        userIterateAndNext(nodep->countp(), WidthVP{SELF, BOTH}.p());
-        userIterateAndNext(nodep->stmtsp(), nullptr);
-    }
+    void visit(AstRepeat* nodep) override { nodep->v3fatalSrc("'repeat' missed in LinkJump"); }
     void visit(AstNodeIf* nodep) override {
         assertAtStatement(nodep);
         // UINFOTREE(1, nodep, "", "IfPre");
@@ -5863,10 +5859,7 @@ class WidthVisitor final : public VNVisitor {
         nodep->text(newFormat);
         UINFO(9, "  Display out " << nodep->text());
     }
-    void visit(AstCReturn* nodep) override {
-        assertAtStatement(nodep);
-        userIterateAndNext(nodep->lhsp(), WidthVP{SELF, BOTH}.p());
-    }
+    void visit(AstCReturn* nodep) override { nodep->v3fatalSrc("Should not exist yet"); }
     void visit(AstConstraintRef* nodep) override { userIterateChildren(nodep, nullptr); }
     void visit(AstDisplay* nodep) override {
         assertAtStatement(nodep);
@@ -6428,23 +6421,7 @@ class WidthVisitor final : public VNVisitor {
         nodep->didWidth(true);
         nodep->doingWidth(false);
     }
-    void visit(AstReturn* nodep) override {
-        // IEEE: Assignment-like context
-        assertAtStatement(nodep);
-        if (!m_funcp) {
-            if (nodep->lhsp()) {  // Return w/o value ok other places
-                nodep->v3error("Return with return value isn't underneath a function");
-            }
-        } else {
-            if (nodep->lhsp()) {
-                // Function hasn't been widthed, so make it so.
-                nodep->dtypeFrom(m_funcp->fvarp());
-                // AstPattern requires assignments to pass datatype on PRELIM
-                userIterateAndNext(nodep->lhsp(), WidthVP{nodep->dtypep(), PRELIM}.p());
-                iterateCheckAssign(nodep, "Return value", nodep->lhsp(), FINAL, nodep->dtypep());
-            }
-        }
-    }
+    void visit(AstReturn* nodep) override { nodep->v3fatalSrc("'return' missed in LinkJump"); }
 
     AstPackage* getItemPackage(AstNode* pkgItemp) {
         while (pkgItemp->backp() && pkgItemp->backp()->nextp() == pkgItemp) {
diff --git a/src/verilog.y b/src/verilog.y
index d833fb098..bbe9b7aef 100644
--- a/src/verilog.y
+++ b/src/verilog.y
@@ -2209,7 +2209,7 @@ tf_variable_identifier<varp>:           // IEEE: part of list_of_tf_variable_ide
                 id variable_dimensionListE sigAttrListE exprEqE
                         { $$ = VARDONEA($<fl>1, *$1, $2, $3);
                           if ($4) AstNode::addNext<AstNode, AstNode>(
-                                      $$, new AstAssign{$4->fileline(), new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1}, $4}); }
+                                      $$, new AstAssign{$4->fileline(), new AstParseRef{$<fl>1, *$1}, $4}); }
         ;
 
 variable_declExpr<nodep>:               // IEEE: part of variable_decl_assignment - rhs of expr
@@ -2974,7 +2974,7 @@ netSig<varp>:                   // IEEE: net_decl_assignment -  one element from
         |       netId variable_dimensionListE sigAttrListE '=' expr
                         { $$ = VARDONEA($<fl>1, *$1, $2, $3);
                           AstDelay* const delayp = $$->delayp() ? $$->delayp()->unlinkFrBack() : nullptr;
-                          AstAssignW* const assignp = new AstAssignW{$4, new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1}, $5, delayp};
+                          AstAssignW* const assignp = new AstAssignW{$4, new AstParseRef{$<fl>1, *$1}, $5, delayp};
                           if (GRAMMARP->m_netStrengthp) assignp->strengthSpecp(GRAMMARP->m_netStrengthp->cloneTree(false));
                           AstNode::addNext<AstNode, AstNode>($$, assignp); }
         ;
@@ -3222,11 +3222,11 @@ instParamItem<pinp>:            // IEEE: named_parameter_assignment + empty
                           $$->svDotName(true); }
         |       '.' idSVKwd
                         { $$ = new AstPin{$<fl>2, PINNUMINC(), *$2,
-                                          new AstParseRef{$<fl>2, VParseRefExp::PX_TEXT, *$2, nullptr, nullptr}};
+                                          new AstParseRef{$<fl>2, *$2, nullptr, nullptr}};
                           $$->svDotName(true); $$->svImplicit(true); }
         |       '.' idAny
                         { $$ = new AstPin{$<fl>2, PINNUMINC(), *$2,
-                                          new AstParseRef{$<fl>2, VParseRefExp::PX_TEXT, *$2, nullptr, nullptr}};
+                                          new AstParseRef{$<fl>2, *$2, nullptr, nullptr}};
                           $$->svDotName(true); $$->svImplicit(true); }
         //                      // mintypmax is expanded here, as it might be a UDP or gate primitive
         //                      // data_type for 'parameter type' hookups
@@ -3261,11 +3261,11 @@ instPinItemE<pinp>:             // IEEE: named_port_connection + empty
                           $$->svDotName(true); }
         |       '.' idSVKwd
                         { $$ = new AstPin{$<fl>2, PINNUMINC(), *$2,
-                                          new AstParseRef{$<fl>2, VParseRefExp::PX_TEXT, *$2, nullptr, nullptr}};
+                                          new AstParseRef{$<fl>2, *$2, nullptr, nullptr}};
                           $$->svDotName(true); $$->svImplicit(true); }
         |       '.' idAny
                         { $$ = new AstPin{$<fl>2, PINNUMINC(), *$2,
-                                          new AstParseRef{$<fl>2, VParseRefExp::PX_TEXT, *$2, nullptr, nullptr}};
+                                          new AstParseRef{$<fl>2, *$2, nullptr, nullptr}};
                           $$->svDotName(true); $$->svImplicit(true); }
         //                      // mintypmax is expanded here, as it might be a UDP or gate primitive
         //UNSUP               pev_expr below
@@ -3916,7 +3916,7 @@ patternKey<nodep>:              // IEEE: merge structure_pattern_key, array_patt
         //                      // expanded from simple_type ps_parameter_identifier (part of simple_type)
         |       packageClassScope id
                         { $$ = AstDot::newIfPkg($<fl>1, $1,
-                                                new AstParseRef{$<fl>2, VParseRefExp::PX_TEXT, *$2, nullptr, nullptr}); }
+                                                new AstParseRef{$<fl>2, *$2, nullptr, nullptr}); }
         |       packageClassScopeE idType
                         { AstRefDType* const refp = new AstRefDType{$<fl>2, *$2, $1, nullptr};
                           $$ = refp; }
@@ -3956,14 +3956,14 @@ for_initializationItem<nodep>:          // IEEE: variable_assignment + for_varia
                           AstVar* const varp = VARDONEA($<fl>2, *$2, nullptr, nullptr);
                           varp->lifetime(VLifetime::AUTOMATIC_EXPLICIT);
                           $$ = varp;
-                          $$->addNext(new AstAssign{$3, new AstParseRef{$<fl>2, VParseRefExp::PX_TEXT, *$2}, $4}); }
+                          $$->addNext(new AstAssign{$3, new AstParseRef{$<fl>2, *$2}, $4}); }
         //                      // IEEE-2012:
         |       yVAR data_type idAny/*new*/ '=' expr
                         { VARRESET_NONLIST(VAR); VARDTYPE($2);
                           AstVar* const varp = VARDONEA($<fl>3, *$3, nullptr, nullptr);
                           varp->lifetime(VLifetime::AUTOMATIC_EXPLICIT);
                           $$ = varp;
-                          $$->addNext(new AstAssign{$4, new AstParseRef{$<fl>3, VParseRefExp::PX_TEXT, *$3}, $5}); }
+                          $$->addNext(new AstAssign{$4, new AstParseRef{$<fl>3, *$3}, $5}); }
         //                      // IEEE: variable_assignment
         //                      // UNSUP variable_lvalue below
         |       id/*newOrExisting*/ '=' expr
@@ -3971,9 +3971,9 @@ for_initializationItem<nodep>:          // IEEE: variable_assignment + for_varia
                               AstVar* const varp = VARDONEA($<fl>1, *$1, nullptr, nullptr);
                               varp->lifetime(VLifetime::AUTOMATIC_EXPLICIT);
                               $$ = varp;
-                              $$->addNext(new AstAssign{$2, new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1}, $3});
+                              $$->addNext(new AstAssign{$2, new AstParseRef{$<fl>1, *$1}, $3});
                           } else {
-                              $$ = new AstAssign{$2, new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1}, $3};
+                              $$ = new AstAssign{$2, new AstParseRef{$<fl>1, *$1}, $3};
                           }
                         }
         ;
@@ -5149,8 +5149,8 @@ exprScope<nodeExprp>:               // scope and variable for use to inside an e
         //                      // IEEE: [ implicit_class_handle . | class_scope | package_scope ] hierarchical_identifier select
         //                      // Or method_call_body without parenthesis
         //                      // See also varRefClassBit, which is the non-expr version of most of this
-                yTHIS                                   { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "this"}; }
-        |       yD_ROOT                                 { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "$root"}; }
+                yTHIS                                   { $$ = new AstParseRef{$<fl>1, "this"}; }
+        |       yD_ROOT                                 { $$ = new AstParseRef{$<fl>1, "$root"}; }
         |       idArrayed                               { $$ = $1; }
         |       packageClassScope idArrayed             { $$ = AstDot::newIfPkg($2->fileline(), $1, $2); }
         |       ~l~expr '.' idArrayed                   { $$ = new AstDot{$<fl>2, false, $1, $3}; }
@@ -5158,14 +5158,14 @@ exprScope<nodeExprp>:               // scope and variable for use to inside an e
         |       ~l~expr '.' ySUPER
                         { AstParseRef* const anodep = VN_CAST($1, ParseRef);
                           if (anodep && anodep->name() == "this") {
-                              $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "super"};
+                              $$ = new AstParseRef{$<fl>1, "super"};
                               $1->deleteTree();
                           } else {
                               $$ = $1;  $$->v3error("Syntax error: 'super' must be first name component, or after 'this.'");
                           }
                         }
         //                      // Part of implicit_class_handle
-        |       ySUPER                                  { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "super"}; }
+        |       ySUPER                                  { $$ = new AstParseRef{$<fl>1, "super"}; }
         ;
 
 fexprScope<nodeExprp>:              // exprScope, For use as first part of statement (disambiguates <=)
@@ -5854,7 +5854,7 @@ idPathpulse<strp>:  // Id for specparam PATHPULSE$, IEEE: part of pulse_control_
 
 idAnyAsParseRef<parseRefp>:  // Any kind of identifier as a ParseRef
                 idAny
-                        { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1}; }
+                        { $$ = new AstParseRef{$<fl>1, *$1}; }
         ;
 
 
@@ -5918,11 +5918,11 @@ idClass<nodeExprp>:             // Misc Ref to dotted, and/or arrayed, and/or bi
                 idDotted                                { $$ = $1; }
         //                      // IEEE: [ implicit_class_handle . | package_scope ] hierarchical_variable_identifier select
         |       yTHIS '.' idDotted
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "this"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "this"}, $3}; }
         |       ySUPER '.' idDotted
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "super"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "super"}, $3}; }
         |       yTHIS '.' ySUPER '.' idDotted
-                        { $$ = new AstDot{$4, false, new AstParseRef{$<fl>3, VParseRefExp::PX_ROOT, "super"}, $5}; }
+                        { $$ = new AstDot{$4, false, new AstParseRef{$<fl>3, "super"}, $5}; }
         //                      // Expanded: package_scope idDottedSel
         |       packageClassScope idDotted              { $$ = new AstDot{$<fl>2, true, $1, $2}; }
         ;
@@ -5931,11 +5931,11 @@ idClassSel<nodeExprp>:          // Misc Ref to dotted, and/or arrayed, and/or bi
                 idDottedSel                             { $$ = $1; }
         //                      // IEEE: [ implicit_class_handle . | package_scope ] hierarchical_variable_identifier select
         |       yTHIS '.' idDottedSel
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "this"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "this"}, $3}; }
         |       ySUPER '.' idDottedSel
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "super"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "super"}, $3}; }
         |       yTHIS '.' ySUPER '.' idDottedSel
-                        { $$ = new AstDot{$4, false, new AstParseRef{$<fl>3, VParseRefExp::PX_ROOT, "super"}, $5}; }
+                        { $$ = new AstDot{$4, false, new AstParseRef{$<fl>3, "super"}, $5}; }
         //                      // Expanded: package_scope idDottedSel
         |       packageClassScope idDottedSel           { $$ = new AstDot{$<fl>2, true, $1, $2}; }
         ;
@@ -5944,30 +5944,30 @@ idClassSelForeach<nodeExprp>:
                 idDottedForeach                         { $$ = $1; }
         //                      // IEEE: [ implicit_class_handle . | package_scope ] hierarchical_variable_identifier select
         |       yTHIS '.' idDottedForeach
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "this"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "this"}, $3}; }
         |       ySUPER '.' idDottedForeach
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "super"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "super"}, $3}; }
         |       yTHIS '.' ySUPER '.' idDottedForeach
-                        { $$ = new AstDot{$4, false, new AstParseRef{$<fl>3, VParseRefExp::PX_ROOT, "super"}, $5}; }
+                        { $$ = new AstDot{$4, false, new AstParseRef{$<fl>3, "super"}, $5}; }
         //                      // Expanded: package_scope idForeach
         |       packageClassScope idDottedForeach       { $$ = new AstDot{$<fl>2, true, $1, $2}; }
         ;
 
 idDotted<nodeExprp>:
                 yD_ROOT '.' idDottedMore
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "$root"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "$root"}, $3}; }
         |       idDottedMore                            { $$ = $1; }
         ;
 
 idDottedSel<nodeExprp>:
                 yD_ROOT '.' idDottedSelMore
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "$root"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "$root"}, $3}; }
         |       idDottedSelMore                         { $$ = $1; }
         ;
 
 idDottedForeach<nodeExprp>:
                 yD_ROOT '.' idDottedMoreForeach
-                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, VParseRefExp::PX_ROOT, "$root"}, $3}; }
+                        { $$ = new AstDot{$2, false, new AstParseRef{$<fl>1, "$root"}, $3}; }
         |       idDottedMoreForeach                     { $$ = $1; }
         ;
 
@@ -5993,7 +5993,7 @@ idDottedMoreForeach<nodeExprp>:
 //       enum_identifier
 idArrayed<nodeExprp>:               // IEEE: id + select
                 id
-                        { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1, nullptr, nullptr}; }
+                        { $$ = new AstParseRef{$<fl>1, *$1, nullptr, nullptr}; }
         //                      // IEEE: id + part_select_range/constant_part_select_range
         |       idArrayed '[' expr ']'                          { $$ = new AstSelBit{$2, $1, $3}; }  // Or AstArraySel, don't know yet.
         |       idArrayed '[' constExpr ':' constExpr ']'       { $$ = new AstSelExtract{$2, $1, $3, $5}; }
@@ -6004,7 +6004,7 @@ idArrayed<nodeExprp>:               // IEEE: id + select
 
 idArrayedForeach<nodeExprp>:    // IEEE: id + select (under foreach expression)
                 id
-                        { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1, nullptr, nullptr}; }
+                        { $$ = new AstParseRef{$<fl>1, *$1, nullptr, nullptr}; }
         //                      // IEEE: id + part_select_range/constant_part_select_range
         |       idArrayed '[' expr ']'                          { $$ = new AstSelBit{$2, $1, $3}; }  // Or AstArraySel, don't know yet.
         |       idArrayed '[' constExpr ':' constExpr ']'       { $$ = new AstSelExtract{$2, $1, $3, $5}; }
@@ -6023,13 +6023,13 @@ idArrayedForeach<nodeExprp>:    // IEEE: id + select (under foreach expression)
 
 // VarRef without any dots or vectorizaion
 varRefBase<parseRefp>:
-                id                                      { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1}; }
+                id                                      { $$ = new AstParseRef{$<fl>1, *$1}; }
         ;
 
 // ParseRef
 parseRefBase<nodep>:
                 id
-                        { $$ = new AstParseRef{$<fl>1, VParseRefExp::PX_TEXT, *$1, nullptr, nullptr}; }
+                        { $$ = new AstParseRef{$<fl>1, *$1, nullptr, nullptr}; }
         ;
 
 // yaSTRING shouldn't be used directly, instead via an abstraction below
@@ -6084,7 +6084,7 @@ clocking_event<senItemp>:       // IEEE: clocking_event
         //UNSUP: '@' idClassSel/*ps_identifier*/
                 '@' id
                         { $$ = new AstSenItem{$<fl>2, VEdgeType::ET_CHANGED,
-                                              new AstParseRef{$<fl>2, VParseRefExp::PX_TEXT, *$2, nullptr, nullptr}}; }
+                                              new AstParseRef{$<fl>2, *$2, nullptr, nullptr}}; }
         |       '@' '(' event_expression ')'            { $$ = $3; }
         ;
 
diff --git a/test_regress/t/t_dist_warn_coverage.py b/test_regress/t/t_dist_warn_coverage.py
index 56cf75a7d..cb64be81d 100755
--- a/test_regress/t/t_dist_warn_coverage.py
+++ b/test_regress/t/t_dist_warn_coverage.py
@@ -26,7 +26,6 @@ for s in [
         'EOF in unterminated string',  # Instead get normal unterminated
         'Enum ranges must be integral, per spec',  # Hard to hit
         'Expecting define formal arguments. Found: ',  # Instead define syntax error
-        'Return with return value isn\'t underneath a function',  # Hard to hit, get other bad return messages
         'Syntax error parsing real: \'',  # Instead can't lex the number
         'Syntax error: Range \':\', \'+:\' etc are not allowed in the instance ',  # Instead get syntax error
         'dynamic new() not expected in this context (expected under an assign)',  # Instead get syntax error
@@ -62,6 +61,7 @@ for s in [
         'Slices of arrays in assignments have different unpacked dimensions, ',
         'String of ',
         'Symbol matching ',
+        'Type cannot be selected from',
         'Unexpected connection to arrayed port',
         'Unsized numbers/parameters not allowed in streams.',
         'Unsupported RHS tristate construct: ',
diff --git a/test_regress/t/t_dump_json.out b/test_regress/t/t_dump_json.out
index ea834db9b..33bac1528 100644
--- a/test_regress/t/t_dump_json.out
+++ b/test_regress/t/t_dump_json.out
@@ -57,7 +57,7 @@
      "rhsp": [
       {"type":"SELEXTRACT","name":"","addr":"(GB)","loc":"e,18:24,18:25","dtypep":"UNLINKED",
        "fromp": [
-        {"type":"PARSEREF","name":"crc","addr":"(HB)","loc":"e,18:21,18:24","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+        {"type":"PARSEREF","name":"crc","addr":"(HB)","loc":"e,18:21,18:24","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
       ],
        "leftp": [
         {"type":"CONST","name":"?32?sh1f","addr":"(IB)","loc":"e,18:25,18:27","dtypep":"(DB)"}
@@ -67,7 +67,7 @@
       ],"attrp": []}
     ],
      "lhsp": [
-      {"type":"PARSEREF","name":"in","addr":"(KB)","loc":"e,18:16,18:18","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+      {"type":"PARSEREF","name":"in","addr":"(KB)","loc":"e,18:16,18:18","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
     ],"timingControlp": [],"strengthSpecp": []},
     {"type":"VAR","name":"out","addr":"(LB)","loc":"e,22:25,22:28","dtypep":"UNLINKED","origName":"out","isSc":false,"isPrimaryIO":false,"isPrimaryClock":false,"direction":"NONE","isConst":false,"isPullup":false,"isPulldown":false,"isSigPublic":false,"isLatched":false,"isUsedLoopIdx":false,"noReset":false,"attrIsolateAssign":false,"attrFileDescr":false,"isDpiOpenArray":false,"isFuncReturn":false,"isFuncLocal":false,"lifetime":"NONE","varType":"WIRE","isSigUserRdPublic":false,"isSigUserRWPublic":false,"isGParam":false,"isParam":false,"attrScBv":false,"attrSFormat":false,"ignorePostWrite":false,"ignoreSchedWrite":false,"sensIfacep":"UNLINKED",
      "childDTypep": [
@@ -88,7 +88,7 @@
        "exprp": [
         {"type":"SELEXTRACT","name":"","addr":"(TB)","loc":"e,27:45,27:46","dtypep":"UNLINKED",
          "fromp": [
-          {"type":"PARSEREF","name":"out","addr":"(UB)","loc":"e,27:42,27:45","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"out","addr":"(UB)","loc":"e,27:42,27:45","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],
          "leftp": [
           {"type":"CONST","name":"?32?sh1f","addr":"(VB)","loc":"e,27:46,27:48","dtypep":"(DB)"}
@@ -99,13 +99,13 @@
       ]},
       {"type":"PIN","name":"clk","addr":"(XB)","loc":"e,29:15,29:18","svDotName":true,"svImplicit":false,"modVarp":"UNLINKED","modPTypep":"UNLINKED",
        "exprp": [
-        {"type":"PARSEREF","name":"clk","addr":"(YB)","loc":"e,29:42,29:45","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+        {"type":"PARSEREF","name":"clk","addr":"(YB)","loc":"e,29:42,29:45","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
       ]},
       {"type":"PIN","name":"in","addr":"(ZB)","loc":"e,30:15,30:17","svDotName":true,"svImplicit":false,"modVarp":"UNLINKED","modPTypep":"UNLINKED",
        "exprp": [
         {"type":"SELEXTRACT","name":"","addr":"(AC)","loc":"e,30:44,30:45","dtypep":"UNLINKED",
          "fromp": [
-          {"type":"PARSEREF","name":"in","addr":"(BC)","loc":"e,30:42,30:44","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"in","addr":"(BC)","loc":"e,30:42,30:44","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],
          "leftp": [
           {"type":"CONST","name":"?32?sh1f","addr":"(CC)","loc":"e,30:45,30:47","dtypep":"(DB)"}
@@ -137,7 +137,7 @@
           {"type":"CONST","name":"32'h0","addr":"(NC)","loc":"e,33:26,33:31","dtypep":"(OC)"}
         ],
          "rhsp": [
-          {"type":"PARSEREF","name":"out","addr":"(PC)","loc":"e,33:33,33:36","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"out","addr":"(PC)","loc":"e,33:33,33:36","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ]}
       ],
        "countp": [
@@ -145,7 +145,7 @@
       ]}
     ],
      "lhsp": [
-      {"type":"PARSEREF","name":"result","addr":"(RC)","loc":"e,33:16,33:22","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+      {"type":"PARSEREF","name":"result","addr":"(RC)","loc":"e,33:16,33:22","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
     ],"timingControlp": [],"strengthSpecp": []},
     {"type":"ALWAYS","name":"","addr":"(SC)","loc":"e,36:4,36:10","keyword":"always","isSuspendable":false,"needProcess":false,"sentreep": [],
      "stmtsp": [
@@ -155,7 +155,7 @@
          "sensesp": [
           {"type":"SENITEM","name":"","addr":"(VC)","loc":"e,36:14,36:21","edgeType":"POS",
            "sensp": [
-            {"type":"PARSEREF","name":"clk","addr":"(WC)","loc":"e,36:22,36:25","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"clk","addr":"(WC)","loc":"e,36:22,36:25","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],"condp": []}
         ]}
       ],
@@ -166,14 +166,14 @@
            "rhsp": [
             {"type":"ADD","name":"","addr":"(ZC)","loc":"e,40:18,40:19","dtypep":"UNLINKED",
              "lhsp": [
-              {"type":"PARSEREF","name":"cyc","addr":"(AD)","loc":"e,40:14,40:17","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"cyc","addr":"(AD)","loc":"e,40:14,40:17","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],
              "rhsp": [
               {"type":"CONST","name":"?32?sh1","addr":"(BD)","loc":"e,40:20,40:21","dtypep":"(N)"}
             ]}
           ],
            "lhsp": [
-            {"type":"PARSEREF","name":"cyc","addr":"(CD)","loc":"e,40:7,40:10","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"cyc","addr":"(CD)","loc":"e,40:7,40:10","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],"timingControlp": []},
           {"type":"ASSIGNDLY","name":"","addr":"(DD)","loc":"e,41:11,41:13","dtypep":"UNLINKED",
            "rhsp": [
@@ -183,7 +183,7 @@
                "lhsp": [
                 {"type":"SELEXTRACT","name":"","addr":"(GD)","loc":"e,41:18,41:19","dtypep":"UNLINKED",
                  "fromp": [
-                  {"type":"PARSEREF","name":"crc","addr":"(HD)","loc":"e,41:15,41:18","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                  {"type":"PARSEREF","name":"crc","addr":"(HD)","loc":"e,41:15,41:18","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                 ],
                  "leftp": [
                   {"type":"CONST","name":"?32?sh3e","addr":"(ID)","loc":"e,41:19,41:21","dtypep":"(S)"}
@@ -199,7 +199,7 @@
                    "lhsp": [
                     {"type":"SELBIT","name":"","addr":"(MD)","loc":"e,41:29,41:30","dtypep":"UNLINKED",
                      "fromp": [
-                      {"type":"PARSEREF","name":"crc","addr":"(ND)","loc":"e,41:26,41:29","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                      {"type":"PARSEREF","name":"crc","addr":"(ND)","loc":"e,41:26,41:29","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                     ],
                      "bitp": [
                       {"type":"CONST","name":"?32?sh3f","addr":"(OD)","loc":"e,41:30,41:32","dtypep":"(S)"}
@@ -208,7 +208,7 @@
                    "rhsp": [
                     {"type":"SELBIT","name":"","addr":"(PD)","loc":"e,41:39,41:40","dtypep":"UNLINKED",
                      "fromp": [
-                      {"type":"PARSEREF","name":"crc","addr":"(QD)","loc":"e,41:36,41:39","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                      {"type":"PARSEREF","name":"crc","addr":"(QD)","loc":"e,41:36,41:39","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                     ],
                      "bitp": [
                       {"type":"CONST","name":"?32?sh2","addr":"(RD)","loc":"e,41:40,41:41","dtypep":"(SD)"}
@@ -218,7 +218,7 @@
                  "rhsp": [
                   {"type":"SELBIT","name":"","addr":"(TD)","loc":"e,41:48,41:49","dtypep":"UNLINKED",
                    "fromp": [
-                    {"type":"PARSEREF","name":"crc","addr":"(UD)","loc":"e,41:45,41:48","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                    {"type":"PARSEREF","name":"crc","addr":"(UD)","loc":"e,41:45,41:48","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                   ],
                    "bitp": [
                     {"type":"CONST","name":"?32?sh0","addr":"(VD)","loc":"e,41:49,41:50","dtypep":"(N)"}
@@ -231,13 +231,13 @@
             ]}
           ],
            "lhsp": [
-            {"type":"PARSEREF","name":"crc","addr":"(XD)","loc":"e,41:7,41:10","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"crc","addr":"(XD)","loc":"e,41:7,41:10","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],"timingControlp": []},
           {"type":"ASSIGNDLY","name":"","addr":"(YD)","loc":"e,42:11,42:13","dtypep":"UNLINKED",
            "rhsp": [
             {"type":"XOR","name":"","addr":"(ZD)","loc":"e,42:21,42:22","dtypep":"UNLINKED",
              "lhsp": [
-              {"type":"PARSEREF","name":"result","addr":"(AE)","loc":"e,42:14,42:20","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"result","addr":"(AE)","loc":"e,42:14,42:20","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],
              "rhsp": [
               {"type":"REPLICATE","name":"","addr":"(BE)","loc":"e,42:23,42:24","dtypep":"(LC)",
@@ -246,7 +246,7 @@
                  "lhsp": [
                   {"type":"SELEXTRACT","name":"","addr":"(DE)","loc":"e,42:27,42:28","dtypep":"UNLINKED",
                    "fromp": [
-                    {"type":"PARSEREF","name":"sum","addr":"(EE)","loc":"e,42:24,42:27","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                    {"type":"PARSEREF","name":"sum","addr":"(EE)","loc":"e,42:24,42:27","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                   ],
                    "leftp": [
                     {"type":"CONST","name":"?32?sh3e","addr":"(FE)","loc":"e,42:28,42:30","dtypep":"(S)"}
@@ -262,7 +262,7 @@
                      "lhsp": [
                       {"type":"SELBIT","name":"","addr":"(JE)","loc":"e,42:38,42:39","dtypep":"UNLINKED",
                        "fromp": [
-                        {"type":"PARSEREF","name":"sum","addr":"(KE)","loc":"e,42:35,42:38","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                        {"type":"PARSEREF","name":"sum","addr":"(KE)","loc":"e,42:35,42:38","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                       ],
                        "bitp": [
                         {"type":"CONST","name":"?32?sh3f","addr":"(LE)","loc":"e,42:39,42:41","dtypep":"(S)"}
@@ -271,7 +271,7 @@
                      "rhsp": [
                       {"type":"SELBIT","name":"","addr":"(ME)","loc":"e,42:48,42:49","dtypep":"UNLINKED",
                        "fromp": [
-                        {"type":"PARSEREF","name":"sum","addr":"(NE)","loc":"e,42:45,42:48","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                        {"type":"PARSEREF","name":"sum","addr":"(NE)","loc":"e,42:45,42:48","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                       ],
                        "bitp": [
                         {"type":"CONST","name":"?32?sh2","addr":"(OE)","loc":"e,42:49,42:50","dtypep":"(SD)"}
@@ -281,7 +281,7 @@
                    "rhsp": [
                     {"type":"SELBIT","name":"","addr":"(PE)","loc":"e,42:57,42:58","dtypep":"UNLINKED",
                      "fromp": [
-                      {"type":"PARSEREF","name":"sum","addr":"(QE)","loc":"e,42:54,42:57","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                      {"type":"PARSEREF","name":"sum","addr":"(QE)","loc":"e,42:54,42:57","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                     ],
                      "bitp": [
                       {"type":"CONST","name":"?32?sh0","addr":"(RE)","loc":"e,42:58,42:59","dtypep":"(N)"}
@@ -295,13 +295,13 @@
             ]}
           ],
            "lhsp": [
-            {"type":"PARSEREF","name":"sum","addr":"(TE)","loc":"e,42:7,42:10","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"sum","addr":"(TE)","loc":"e,42:7,42:10","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],"timingControlp": []},
           {"type":"IF","name":"","addr":"(UE)","loc":"e,43:7,43:9",
            "condp": [
             {"type":"EQ","name":"","addr":"(VE)","loc":"e,43:15,43:17","dtypep":"(WE)",
              "lhsp": [
-              {"type":"PARSEREF","name":"cyc","addr":"(XE)","loc":"e,43:11,43:14","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"cyc","addr":"(XE)","loc":"e,43:11,43:14","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],
              "rhsp": [
               {"type":"CONST","name":"?32?sh0","addr":"(YE)","loc":"e,43:18,43:19","dtypep":"(N)"}
@@ -315,14 +315,14 @@
                 {"type":"CONST","name":"64'h5aef0c8dd70a4497","addr":"(BF)","loc":"e,45:17,45:38","dtypep":"(CF)"}
               ],
                "lhsp": [
-                {"type":"PARSEREF","name":"crc","addr":"(DF)","loc":"e,45:10,45:13","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"crc","addr":"(DF)","loc":"e,45:10,45:13","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ],"timingControlp": []},
               {"type":"ASSIGNDLY","name":"","addr":"(EF)","loc":"e,46:14,46:16","dtypep":"UNLINKED",
                "rhsp": [
                 {"type":"CONST","name":"'0","addr":"(FF)","loc":"e,46:17,46:19","dtypep":"(WE)"}
               ],
                "lhsp": [
-                {"type":"PARSEREF","name":"sum","addr":"(GF)","loc":"e,46:10,46:13","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"sum","addr":"(GF)","loc":"e,46:10,46:13","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ],"timingControlp": []}
             ]}
           ],
@@ -331,7 +331,7 @@
              "condp": [
               {"type":"LT","name":"","addr":"(IF)","loc":"e,48:20,48:21","dtypep":"(WE)",
                "lhsp": [
-                {"type":"PARSEREF","name":"cyc","addr":"(JF)","loc":"e,48:16,48:19","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"cyc","addr":"(JF)","loc":"e,48:16,48:19","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ],
                "rhsp": [
                 {"type":"CONST","name":"?32?sha","addr":"(KF)","loc":"e,48:22,48:24","dtypep":"(LF)"}
@@ -345,7 +345,7 @@
                   {"type":"CONST","name":"'0","addr":"(OF)","loc":"e,49:17,49:19","dtypep":"(WE)"}
                 ],
                  "lhsp": [
-                  {"type":"PARSEREF","name":"sum","addr":"(PF)","loc":"e,49:10,49:13","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                  {"type":"PARSEREF","name":"sum","addr":"(PF)","loc":"e,49:10,49:13","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                 ],"timingControlp": []}
               ]}
             ],
@@ -354,7 +354,7 @@
                "condp": [
                 {"type":"LT","name":"","addr":"(RF)","loc":"e,51:20,51:21","dtypep":"(WE)",
                  "lhsp": [
-                  {"type":"PARSEREF","name":"cyc","addr":"(SF)","loc":"e,51:16,51:19","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                  {"type":"PARSEREF","name":"cyc","addr":"(SF)","loc":"e,51:16,51:19","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                 ],
                  "rhsp": [
                   {"type":"CONST","name":"?32?sh5a","addr":"(TF)","loc":"e,51:22,51:24","dtypep":"(UF)"}
@@ -368,7 +368,7 @@
                  "condp": [
                   {"type":"EQ","name":"","addr":"(XF)","loc":"e,53:20,53:22","dtypep":"(WE)",
                    "lhsp": [
-                    {"type":"PARSEREF","name":"cyc","addr":"(YF)","loc":"e,53:16,53:19","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                    {"type":"PARSEREF","name":"cyc","addr":"(YF)","loc":"e,53:16,53:19","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                   ],
                    "rhsp": [
                     {"type":"CONST","name":"?32?sh63","addr":"(ZF)","loc":"e,53:23,53:25","dtypep":"(UF)"}
@@ -383,16 +383,16 @@
                        "exprsp": [
                         {"type":"CONST","name":"232'h5b2530745d206379633d3d253064206372633d25782073756d3d25780a","addr":"(EG)","loc":"e,54:17,54:49","dtypep":"(FG)"},
                         {"type":"TIME","name":"","addr":"(GG)","loc":"e,54:51,54:56","dtypep":"(HG)","timeunit":"NONE"},
-                        {"type":"PARSEREF","name":"cyc","addr":"(IG)","loc":"e,54:58,54:61","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []},
-                        {"type":"PARSEREF","name":"crc","addr":"(JG)","loc":"e,54:63,54:66","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []},
-                        {"type":"PARSEREF","name":"sum","addr":"(KG)","loc":"e,54:68,54:71","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                        {"type":"PARSEREF","name":"cyc","addr":"(IG)","loc":"e,54:58,54:61","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []},
+                        {"type":"PARSEREF","name":"crc","addr":"(JG)","loc":"e,54:63,54:66","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []},
+                        {"type":"PARSEREF","name":"sum","addr":"(KG)","loc":"e,54:68,54:71","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                       ],"scopeNamep": []}
                     ],"filep": []},
                     {"type":"IF","name":"","addr":"(LG)","loc":"e,55:10,55:12",
                      "condp": [
                       {"type":"NEQCASE","name":"","addr":"(MG)","loc":"e,55:18,55:21","dtypep":"(WE)",
                        "lhsp": [
-                        {"type":"PARSEREF","name":"crc","addr":"(NG)","loc":"e,55:14,55:17","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                        {"type":"PARSEREF","name":"crc","addr":"(NG)","loc":"e,55:14,55:17","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                       ],
                        "rhsp": [
                         {"type":"CONST","name":"64'hc77bb9b3784ea091","addr":"(OG)","loc":"e,55:22,55:42","dtypep":"(CF)"}
@@ -405,7 +405,7 @@
                      "condp": [
                       {"type":"NEQCASE","name":"","addr":"(RG)","loc":"e,58:18,58:21","dtypep":"(WE)",
                        "lhsp": [
-                        {"type":"PARSEREF","name":"sum","addr":"(SG)","loc":"e,58:14,58:17","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                        {"type":"PARSEREF","name":"sum","addr":"(SG)","loc":"e,58:14,58:17","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                       ],
                        "rhsp": [
                         {"type":"CONST","name":"64'h4afe43fb79d7b71e","addr":"(TG)","loc":"e,58:22,58:42","dtypep":"(CF)"}
@@ -474,7 +474,7 @@
          "sensesp": [
           {"type":"SENITEM","name":"","addr":"(SH)","loc":"e,82:13,82:20","edgeType":"POS",
            "sensp": [
-            {"type":"PARSEREF","name":"clk","addr":"(TH)","loc":"e,82:21,82:24","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"clk","addr":"(TH)","loc":"e,82:21,82:24","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],"condp": []}
         ]}
       ],
@@ -483,10 +483,10 @@
          "stmtsp": [
           {"type":"ASSIGNDLY","name":"","addr":"(VH)","loc":"e,83:11,83:13","dtypep":"UNLINKED",
            "rhsp": [
-            {"type":"PARSEREF","name":"in","addr":"(WH)","loc":"e,83:14,83:16","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"in","addr":"(WH)","loc":"e,83:14,83:16","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],
            "lhsp": [
-            {"type":"PARSEREF","name":"out","addr":"(XH)","loc":"e,83:7,83:10","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"out","addr":"(XH)","loc":"e,83:7,83:10","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],"timingControlp": []},
           {"type":"ASSERTCTL","name":"","addr":"(YH)","loc":"e,86:7,86:17",
            "controlTypep": [
@@ -533,7 +533,7 @@
            "stmtsp": [
             {"type":"DISABLE","name":"","addr":"(QI)","loc":"e,92:10,92:17",
              "targetRefp": [
-              {"type":"PARSEREF","name":"blk","addr":"(RI)","loc":"e,92:18,92:21","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"blk","addr":"(RI)","loc":"e,92:18,92:21","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ]}
           ]}
         ]}
@@ -976,7 +976,7 @@
        "sensesp": [
         {"type":"SENITEM","name":"","addr":"(XO)","loc":"e,127:9,127:16","edgeType":"POS",
          "sensp": [
-          {"type":"PARSEREF","name":"clk","addr":"(YO)","loc":"e,127:17,127:20","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"clk","addr":"(YO)","loc":"e,127:17,127:20","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],"condp": []}
       ],"disablep": [],
        "propp": [
@@ -991,7 +991,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(DP)","loc":"e,130:40,130:44","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(EP)","loc":"e,130:40,130:44","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(EP)","loc":"e,130:40,130:44","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],"failsp": [],"passsp": []}
@@ -1004,7 +1004,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(IP)","loc":"e,131:44,131:48","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(JP)","loc":"e,131:44,131:48","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(JP)","loc":"e,131:44,131:48","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],
@@ -1026,7 +1026,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(QP)","loc":"e,132:44,132:48","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(RP)","loc":"e,132:44,132:48","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(RP)","loc":"e,132:44,132:48","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],"failsp": [],
@@ -1048,7 +1048,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(YP)","loc":"e,133:49,133:53","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(ZP)","loc":"e,133:49,133:53","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(ZP)","loc":"e,133:49,133:53","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],
@@ -1079,7 +1079,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(JQ)","loc":"e,135:39,135:43","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(KQ)","loc":"e,135:39,135:43","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(KQ)","loc":"e,135:39,135:43","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],"failsp": [],"passsp": []}
@@ -1092,7 +1092,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(OQ)","loc":"e,136:44,136:48","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(PQ)","loc":"e,136:44,136:48","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(PQ)","loc":"e,136:44,136:48","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],
@@ -1114,7 +1114,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(WQ)","loc":"e,137:44,137:48","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(XQ)","loc":"e,137:44,137:48","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(XQ)","loc":"e,137:44,137:48","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],"failsp": [],
@@ -1136,7 +1136,7 @@
          "exprp": [
           {"type":"PROPSPEC","name":"","addr":"(ER)","loc":"e,138:49,138:53","dtypep":"UNLINKED","sensesp": [],"disablep": [],
            "propp": [
-            {"type":"PARSEREF","name":"prop","addr":"(FR)","loc":"e,138:49,138:53","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"prop","addr":"(FR)","loc":"e,138:49,138:53","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ]}
       ],"sentreep": [],
@@ -1165,7 +1165,7 @@
        "propp": [
         {"type":"PROPSPEC","name":"","addr":"(OR)","loc":"e,140:37,140:41","dtypep":"UNLINKED","sensesp": [],"disablep": [],
          "propp": [
-          {"type":"PARSEREF","name":"prop","addr":"(PR)","loc":"e,140:37,140:41","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"prop","addr":"(PR)","loc":"e,140:37,140:41","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ]}
       ],"sentreep": [],"coverincsp": [],"passsp": []}
     ]},
@@ -1175,7 +1175,7 @@
        "propp": [
         {"type":"PROPSPEC","name":"","addr":"(SR)","loc":"e,141:42,141:46","dtypep":"UNLINKED","sensesp": [],"disablep": [],
          "propp": [
-          {"type":"PARSEREF","name":"prop","addr":"(TR)","loc":"e,141:42,141:46","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"prop","addr":"(TR)","loc":"e,141:42,141:46","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ]}
       ],"sentreep": [],"coverincsp": [],
        "passsp": [
@@ -1192,7 +1192,7 @@
      "propp": [
       {"type":"PROPSPEC","name":"","addr":"(YR)","loc":"e,143:23,143:27","dtypep":"UNLINKED","sensesp": [],"disablep": [],
        "propp": [
-        {"type":"PARSEREF","name":"prop","addr":"(ZR)","loc":"e,143:23,143:27","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+        {"type":"PARSEREF","name":"prop","addr":"(ZR)","loc":"e,143:23,143:27","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
       ]}
     ],"sentreep": [],"passsp": []}
   ]},
@@ -1234,10 +1234,10 @@
         ],"attrsp": []},
         {"type":"ASSIGN","name":"","addr":"(QS)","loc":"d,39:15,39:16","dtypep":"UNLINKED",
          "rhsp": [
-          {"type":"PARSEREF","name":"bound","addr":"(RS)","loc":"d,39:17,39:22","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"bound","addr":"(RS)","loc":"d,39:17,39:22","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],
          "lhsp": [
-          {"type":"PARSEREF","name":"m_bound","addr":"(SS)","loc":"d,39:7,39:14","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"m_bound","addr":"(SS)","loc":"d,39:7,39:14","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],"timingControlp": []}
       ],"scopeNamep": []},
       {"type":"FUNC","name":"num","addr":"(TS)","loc":"d,42:18,42:21","dtypep":"UNLINKED","method":false,"dpiExport":false,"dpiImport":false,"dpiOpenChild":false,"dpiOpenParent":false,"isExternDef":false,"isExternProto":false,"prototype":false,"recursive":false,"taskPublic":false,"cname":"num",
@@ -1249,7 +1249,7 @@
          "lhsp": [
           {"type":"DOT","name":"","addr":"(WS)","loc":"d,43:21,43:22","dtypep":"UNLINKED","colon":false,
            "lhsp": [
-            {"type":"PARSEREF","name":"m_queue","addr":"(XS)","loc":"d,43:14,43:21","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"m_queue","addr":"(XS)","loc":"d,43:14,43:21","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],
            "rhsp": [
             {"type":"FUNCREF","name":"size","addr":"(YS)","loc":"d,43:22,43:26","dtypep":"UNLINKED","dotted":"","taskp":"UNLINKED","classOrPackagep":"UNLINKED","namep": [],"pinsp": [],"scopeNamep": []}
@@ -1278,7 +1278,7 @@
            "lhsp": [
             {"type":"EQ","name":"","addr":"(IT)","loc":"d,55:19,55:21","dtypep":"(WE)",
              "lhsp": [
-              {"type":"PARSEREF","name":"m_bound","addr":"(JT)","loc":"d,55:11,55:18","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"m_bound","addr":"(JT)","loc":"d,55:11,55:18","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],
              "rhsp": [
               {"type":"CONST","name":"?32?sh0","addr":"(KT)","loc":"d,55:22,55:23","dtypep":"(N)"}
@@ -1290,7 +1290,7 @@
               {"type":"FUNCREF","name":"num","addr":"(MT)","loc":"d,55:27,55:30","dtypep":"UNLINKED","dotted":"","taskp":"UNLINKED","classOrPackagep":"UNLINKED","namep": [],"pinsp": [],"scopeNamep": []}
             ],
              "rhsp": [
-              {"type":"PARSEREF","name":"m_bound","addr":"(NT)","loc":"d,55:35,55:42","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"m_bound","addr":"(NT)","loc":"d,55:35,55:42","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ]}
           ]}
         ],
@@ -1301,14 +1301,14 @@
              "exprp": [
               {"type":"DOT","name":"","addr":"(QT)","loc":"d,56:16,56:17","dtypep":"UNLINKED","colon":false,
                "lhsp": [
-                {"type":"PARSEREF","name":"m_queue","addr":"(RT)","loc":"d,56:9,56:16","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"m_queue","addr":"(RT)","loc":"d,56:9,56:16","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ],
                "rhsp": [
                 {"type":"TASKREF","name":"push_back","addr":"(ST)","loc":"d,56:17,56:26","dtypep":"(TT)","dotted":"","taskp":"UNLINKED","classOrPackagep":"UNLINKED","namep": [],
                  "pinsp": [
                   {"type":"ARG","name":"","addr":"(UT)","loc":"d,56:27,56:34",
                    "exprp": [
-                    {"type":"PARSEREF","name":"message","addr":"(VT)","loc":"d,56:27,56:34","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                    {"type":"PARSEREF","name":"message","addr":"(VT)","loc":"d,56:27,56:34","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
                   ]}
                 ],"scopeNamep": []}
               ]}
@@ -1357,14 +1357,14 @@
              "rhsp": [
               {"type":"DOT","name":"","addr":"(NU)","loc":"d,73:26,73:27","dtypep":"UNLINKED","colon":false,
                "lhsp": [
-                {"type":"PARSEREF","name":"m_queue","addr":"(OU)","loc":"d,73:19,73:26","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"m_queue","addr":"(OU)","loc":"d,73:19,73:26","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ],
                "rhsp": [
                 {"type":"FUNCREF","name":"pop_front","addr":"(PU)","loc":"d,73:27,73:36","dtypep":"UNLINKED","dotted":"","taskp":"UNLINKED","classOrPackagep":"UNLINKED","namep": [],"pinsp": [],"scopeNamep": []}
               ]}
             ],
              "lhsp": [
-              {"type":"PARSEREF","name":"message","addr":"(QU)","loc":"d,73:9,73:16","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"message","addr":"(QU)","loc":"d,73:9,73:16","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],"timingControlp": []},
             {"type":"RETURN","name":"","addr":"(RU)","loc":"d,74:9,74:15",
              "lhsp": [
@@ -1410,14 +1410,14 @@
              "rhsp": [
               {"type":"SELBIT","name":"","addr":"(IV)","loc":"d,90:26,90:27","dtypep":"UNLINKED",
                "fromp": [
-                {"type":"PARSEREF","name":"m_queue","addr":"(JV)","loc":"d,90:19,90:26","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"m_queue","addr":"(JV)","loc":"d,90:19,90:26","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ],
                "bitp": [
                 {"type":"CONST","name":"?32?sh0","addr":"(KV)","loc":"d,90:27,90:28","dtypep":"(N)"}
               ],"thsp": [],"attrp": []}
             ],
              "lhsp": [
-              {"type":"PARSEREF","name":"message","addr":"(LV)","loc":"d,90:9,90:16","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"message","addr":"(LV)","loc":"d,90:9,90:16","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],"timingControlp": []},
             {"type":"RETURN","name":"","addr":"(MV)","loc":"d,91:9,91:15",
              "lhsp": [
@@ -1448,10 +1448,10 @@
         ],"attrsp": []},
         {"type":"ASSIGN","name":"","addr":"(XV)","loc":"d,101:18,101:19","dtypep":"UNLINKED",
          "rhsp": [
-          {"type":"PARSEREF","name":"keyCount","addr":"(YV)","loc":"d,101:20,101:28","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"keyCount","addr":"(YV)","loc":"d,101:20,101:28","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],
          "lhsp": [
-          {"type":"PARSEREF","name":"m_keyCount","addr":"(ZV)","loc":"d,101:7,101:17","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"m_keyCount","addr":"(ZV)","loc":"d,101:7,101:17","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],"timingControlp": []}
       ],"scopeNamep": []},
       {"type":"TASK","name":"put","addr":"(AW)","loc":"d,104:19,104:22","method":false,"dpiExport":false,"dpiImport":false,"dpiOpenChild":false,"dpiOpenParent":false,"isExternDef":false,"isExternProto":false,"prototype":false,"recursive":false,"taskPublic":false,"cname":"put","fvarp": [],"classOrPackagep": [],
@@ -1467,14 +1467,14 @@
          "rhsp": [
           {"type":"ADD","name":"","addr":"(FW)","loc":"d,105:18,105:20","dtypep":"UNLINKED",
            "lhsp": [
-            {"type":"PARSEREF","name":"m_keyCount","addr":"(GW)","loc":"d,105:7,105:17","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"m_keyCount","addr":"(GW)","loc":"d,105:7,105:17","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],
            "rhsp": [
-            {"type":"PARSEREF","name":"keyCount","addr":"(HW)","loc":"d,105:21,105:29","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"keyCount","addr":"(HW)","loc":"d,105:21,105:29","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ],
          "lhsp": [
-          {"type":"PARSEREF","name":"m_keyCount","addr":"(IW)","loc":"d,105:7,105:17","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"m_keyCount","addr":"(IW)","loc":"d,105:7,105:17","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ],"timingControlp": []}
       ],"scopeNamep": []},
       {"type":"TASK","name":"get","addr":"(JW)","loc":"d,108:10,108:13","method":false,"dpiExport":false,"dpiImport":false,"dpiOpenChild":false,"dpiOpenParent":false,"isExternDef":false,"isExternProto":false,"prototype":false,"recursive":false,"taskPublic":false,"cname":"get","fvarp": [],"classOrPackagep": [],
@@ -1503,10 +1503,10 @@
          "condp": [
           {"type":"GTE","name":"","addr":"(TW)","loc":"d,118:22,118:24","dtypep":"(WE)",
            "lhsp": [
-            {"type":"PARSEREF","name":"m_keyCount","addr":"(UW)","loc":"d,118:11,118:21","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"m_keyCount","addr":"(UW)","loc":"d,118:11,118:21","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],
            "rhsp": [
-            {"type":"PARSEREF","name":"keyCount","addr":"(VW)","loc":"d,118:25,118:33","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"keyCount","addr":"(VW)","loc":"d,118:25,118:33","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ]}
         ],
          "thensp": [
@@ -1516,14 +1516,14 @@
              "rhsp": [
               {"type":"SUB","name":"","addr":"(YW)","loc":"d,119:20,119:22","dtypep":"UNLINKED",
                "lhsp": [
-                {"type":"PARSEREF","name":"m_keyCount","addr":"(ZW)","loc":"d,119:9,119:19","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"m_keyCount","addr":"(ZW)","loc":"d,119:9,119:19","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ],
                "rhsp": [
-                {"type":"PARSEREF","name":"keyCount","addr":"(AX)","loc":"d,119:23,119:31","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+                {"type":"PARSEREF","name":"keyCount","addr":"(AX)","loc":"d,119:23,119:31","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
               ]}
             ],
              "lhsp": [
-              {"type":"PARSEREF","name":"m_keyCount","addr":"(BX)","loc":"d,119:9,119:19","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"m_keyCount","addr":"(BX)","loc":"d,119:9,119:19","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],"timingControlp": []},
             {"type":"RETURN","name":"","addr":"(CX)","loc":"d,120:9,120:15",
              "lhsp": [
@@ -1585,7 +1585,7 @@
         ],"attrsp": []},
         {"type":"RETURN","name":"","addr":"(BY)","loc":"d,145:7,145:13",
          "lhsp": [
-          {"type":"PARSEREF","name":"p","addr":"(CY)","loc":"d,145:14,145:15","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"p","addr":"(CY)","loc":"d,145:14,145:15","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ]}
       ],"scopeNamep": []},
       {"type":"TASK","name":"set_status","addr":"(DY)","loc":"d,148:29,148:39","method":false,"dpiExport":false,"dpiImport":false,"dpiOpenChild":false,"dpiOpenParent":false,"isExternDef":false,"isExternProto":false,"prototype":false,"recursive":false,"taskPublic":false,"cname":"set_status","fvarp": [],"classOrPackagep": [],
@@ -1602,7 +1602,7 @@
        "stmtsp": [
         {"type":"RETURN","name":"","addr":"(IY)","loc":"d,158:7,158:13",
          "lhsp": [
-          {"type":"PARSEREF","name":"RUNNING","addr":"(JY)","loc":"d,158:14,158:21","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"RUNNING","addr":"(JY)","loc":"d,158:14,158:21","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ]}
       ],"scopeNamep": []},
       {"type":"TASK","name":"kill","addr":"(KY)","loc":"d,162:19,162:23","method":false,"dpiExport":false,"dpiImport":false,"dpiOpenChild":false,"dpiOpenParent":false,"isExternDef":false,"isExternProto":false,"prototype":false,"recursive":false,"taskPublic":false,"cname":"kill","fvarp": [],"classOrPackagep": [],
@@ -1613,7 +1613,7 @@
            "pinsp": [
             {"type":"ARG","name":"","addr":"(NY)","loc":"d,163:18,163:24",
              "exprp": [
-              {"type":"PARSEREF","name":"KILLED","addr":"(OY)","loc":"d,163:18,163:24","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"KILLED","addr":"(OY)","loc":"d,163:18,163:24","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ]}
           ],"scopeNamep": []}
         ]}
@@ -1637,7 +1637,7 @@
            "pinsp": [
             {"type":"ARG","name":"","addr":"(YY)","loc":"d,171:18,171:25",
              "exprp": [
-              {"type":"PARSEREF","name":"RUNNING","addr":"(ZY)","loc":"d,171:18,171:25","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"RUNNING","addr":"(ZY)","loc":"d,171:18,171:25","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ]}
           ],"scopeNamep": []}
         ]}
@@ -1669,7 +1669,7 @@
          "exprp": [
           {"type":"DOT","name":"","addr":"(LZ)","loc":"d,230:8,230:9","dtypep":"UNLINKED","colon":false,
            "lhsp": [
-            {"type":"PARSEREF","name":"s","addr":"(MZ)","loc":"d,230:7,230:8","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+            {"type":"PARSEREF","name":"s","addr":"(MZ)","loc":"d,230:7,230:8","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
           ],
            "rhsp": [
             {"type":"TASKREF","name":"itoa","addr":"(NZ)","loc":"d,230:9,230:13","dtypep":"(TT)","dotted":"","taskp":"UNLINKED","classOrPackagep":"UNLINKED","namep": [],
@@ -1687,13 +1687,13 @@
            "pinsp": [
             {"type":"ARG","name":"","addr":"(SZ)","loc":"d,231:21,231:22",
              "exprp": [
-              {"type":"PARSEREF","name":"s","addr":"(TZ)","loc":"d,231:21,231:22","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"s","addr":"(TZ)","loc":"d,231:21,231:22","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ]}
           ],"scopeNamep": []}
         ]},
         {"type":"RETURN","name":"","addr":"(UZ)","loc":"d,232:7,232:13",
          "lhsp": [
-          {"type":"PARSEREF","name":"s","addr":"(VZ)","loc":"d,232:14,232:15","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+          {"type":"PARSEREF","name":"s","addr":"(VZ)","loc":"d,232:14,232:15","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
         ]}
       ],"scopeNamep": []},
       {"type":"TASK","name":"set_randstate","addr":"(WZ)","loc":"d,235:19,235:32","method":false,"dpiExport":false,"dpiImport":false,"dpiOpenChild":false,"dpiOpenParent":false,"isExternDef":false,"isExternProto":false,"prototype":false,"recursive":false,"taskPublic":false,"cname":"set_randstate","fvarp": [],"classOrPackagep": [],
@@ -1708,7 +1708,7 @@
            "seedp": [
             {"type":"DOT","name":"","addr":"(BAB)","loc":"d,236:17,236:18","dtypep":"UNLINKED","colon":false,
              "lhsp": [
-              {"type":"PARSEREF","name":"s","addr":"(CAB)","loc":"d,236:16,236:17","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+              {"type":"PARSEREF","name":"s","addr":"(CAB)","loc":"d,236:16,236:17","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
             ],
              "rhsp": [
               {"type":"FUNCREF","name":"atoi","addr":"(DAB)","loc":"d,236:18,236:22","dtypep":"UNLINKED","dotted":"","taskp":"UNLINKED","classOrPackagep":"UNLINKED","namep": [],"pinsp": [],"scopeNamep": []}
@@ -1727,7 +1727,7 @@
         {"type":"CONST","name":"?32?sh0","addr":"(HAB)","loc":"d,240:17,240:18","dtypep":"(N)"}
       ],
        "lhsp": [
-        {"type":"PARSEREF","name":"randomize","addr":"(IAB)","loc":"d,240:5,240:14","dtypep":"UNLINKED","expect":"TEXT","lhsp": [],"ftaskrefp": []}
+        {"type":"PARSEREF","name":"randomize","addr":"(IAB)","loc":"d,240:5,240:14","dtypep":"UNLINKED","lhsp": [],"ftaskrefp": []}
       ],"timingControlp": []}
     ],"scopeNamep": []}
   ]}