diff --git a/docs/internals.rst b/docs/internals.rst
index d2424c403..c2031c857 100644
--- a/docs/internals.rst
+++ b/docs/internals.rst
@@ -1047,9 +1047,9 @@ Generating ``AstNode`` members
 Some of the member s of ``AstNode`` sub-classes are generated by ``astgen``.
 These are emitted as pre-processor macro definitions, which then need to be
 added to the ``AstNode`` sub-classes they correspond to. Specifically ``class
-AstFoo`` should contain an instance of ``ASTGEN_MEMBERS_Foo;`` at class scope.
-The ``astgen`` script checks and errors if this is not present. The method
-generated depends on whether the class is a concrete final class, or an
+AstFoo`` should contain an instance of ``ASTGEN_MEMBERS_AstFoo;`` at class
+scope.  The ``astgen`` script checks and errors if this is not present. The
+method generated depends on whether the class is a concrete final class, or an
 abstract ``AstNode*`` base-class, and on ``@astgen`` directives present in
 comment sections in the body of the ``AstNode`` sub-class definitions.
 
diff --git a/src/Makefile_obj.in b/src/Makefile_obj.in
index a6430e10c..503fb540f 100644
--- a/src/Makefile_obj.in
+++ b/src/Makefile_obj.in
@@ -289,6 +289,7 @@ NON_STANDALONE_HEADERS = \
 	V3AstNodeDType.h  \
 	V3AstNodeMath.h  \
 	V3AstNodeOther.h  \
+	V3DfgVertices.h  \
 	V3WidthCommit.h  \
 
 AST_DEFS := \
@@ -296,10 +297,19 @@ AST_DEFS := \
   V3AstNodeMath.h \
   V3AstNodeOther.h \
 
+DFG_DEFS := \
+  V3DfgVertices.h
+
+#### astgen common flags
+
+ASTGENFLAGS = -I $(srcdir)
+ASTGENFLAGS += $(foreach f,$(AST_DEFS),--astdef $f)
+ASTGENFLAGS += $(foreach f,$(DFG_DEFS),--dfgdef $f)
+
 #### Linking
 
 ifeq ($(VL_VLCOV),)
-PREDEP_H = V3Ast__gen_classes.h
+PREDEP_H = V3Ast__gen_forward_class_decls.h
 OBJS += $(RAW_OBJS) $(NC_OBJS)
 else
 PREDEP_H =
@@ -318,8 +328,8 @@ V3Number_test: V3Number_test.o
 
 #### Modules
 
-%__gen.cpp:	%.cpp $(ASTGEN) $(AST_DEFS)
-	$(PYTHON3) $(ASTGEN) -I $(srcdir) $(foreach f,$(AST_DEFS),--astdef $f) $*.cpp
+%__gen.cpp:	%.cpp $(ASTGEN) $(AST_DEFS) $(DFG_DEFS)
+	$(PYTHON3) $(ASTGEN) $(ASTGENFLAGS) $*.cpp
 
 %.o:	%.cpp
 	$(OBJCACHE) ${CXX} ${CXXFLAGS} ${CPPFLAGSWALL} -c $< -o $@
@@ -341,7 +351,7 @@ V3PreProc.o:	V3PreProc.cpp V3PreLex.yy.cpp
 #### Generated files
 
 # Target rule called before parallel build to make generated files
-serial:: V3Ast__gen_classes.h V3ParseBison.c
+serial:: V3Ast__gen_forward_class_decls.h V3ParseBison.c
 
 serial_vlcov:: vlcovgen.d
 
@@ -349,8 +359,8 @@ vlcovgen.d: $(VLCOVGEN) $(srcdir)/../include/verilated_cov_key.h
 	$(PYTHON3) $(VLCOVGEN) --srcdir $(srcdir)
 	touch $@
 
-V3Ast__gen_classes.h : $(ASTGEN) $(AST_DEFS)
-	$(PYTHON3) $(ASTGEN) -I $(srcdir) $(foreach f,$(AST_DEFS),--astdef $f) --classes
+V3Ast__gen_forward_class_decls.h: $(ASTGEN) $(AST_DEFS) $(DFG_DEFS)
+	$(PYTHON3) $(ASTGEN) $(ASTGENFLAGS) --classes
 
 V3ParseBison.h: V3ParseBison.c
 
diff --git a/src/V3Ast.h b/src/V3Ast.h
index 71a86943c..fa33caca9 100644
--- a/src/V3Ast.h
+++ b/src/V3Ast.h
@@ -26,7 +26,7 @@
 #include "V3Global.h"
 #include "V3Number.h"
 
-#include "V3Ast__gen_classes.h"  // From ./astgen
+#include "V3Ast__gen_forward_class_decls.h"  // From ./astgen
 
 #include <cmath>
 #include <functional>
@@ -87,7 +87,7 @@ using MTaskIdSet = std::set<int>;  // Set of mtaskIds for Var sorting
 
 class VNType final {
 public:
-#include "V3Ast__gen_types.h"  // From ./astgen
+#include "V3Ast__gen_type_enum.h"  // From ./astgen
     // Above include has:
     //   enum en {...};
     //   const char* ascii() const {...};
@@ -2179,7 +2179,7 @@ void AstNode::addPrev(AstNode* newp) {
 }
 
 // Specialisations of privateTypeTest
-#include "V3Ast__gen_impl.h"  // From ./astgen
+#include "V3Ast__gen_type_tests.h"  // From ./astgen
 
 // Specializations of AstNode::mayBeUnder
 template <>
@@ -2478,7 +2478,7 @@ AstNode* VNVisitor::iterateSubtreeReturnEdits(AstNode* nodep) {
     return nodep->iterateSubtreeReturnEdits(*this);
 }
 
-// Include macros generated by 'astgen'. These include ASTGEN_MEMBERS_<Node>
+// Include macros generated by 'astgen'. These include ASTGEN_MEMBERS_Ast<Node>
 // for each AstNode sub-type, and ASTGEN_SUPER_<Node> for concrete final
 // AstNode sub-types. The generated members include boilerplate methods related
 // to cloning, visitor dispatch, and other functionality. ASTGEN_SUPER_<Node>
diff --git a/src/V3AstNodeDType.h b/src/V3AstNodeDType.h
index c30a18abf..c3f4d096e 100644
--- a/src/V3AstNodeDType.h
+++ b/src/V3AstNodeDType.h
@@ -50,7 +50,7 @@ protected:
         : AstNode{t, fl} {}
 
 public:
-    ASTGEN_MEMBERS_NodeDType;
+    ASTGEN_MEMBERS_AstNodeDType;
     // ACCESSORS
     void dump(std::ostream& str) const override;
     virtual void dumpSmall(std::ostream& str) const;
@@ -144,7 +144,7 @@ protected:
         : AstNodeDType{t, fl} {}
 
 public:
-    ASTGEN_MEMBERS_NodeArrayDType;
+    ASTGEN_MEMBERS_AstNodeArrayDType;
     void dump(std::ostream& str) const override;
     void dumpSmall(std::ostream& str) const override;
     const char* broken() const override {
@@ -212,7 +212,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeUOrStructDType;
+    ASTGEN_MEMBERS_AstNodeUOrStructDType;
     int uniqueNum() const { return m_uniqueNum; }
     const char* broken() const override;
     void dump(std::ostream& str) const override;
@@ -270,7 +270,7 @@ public:
         this->rangep(rangep);
         this->valuep(valuep);
     }
-    ASTGEN_MEMBERS_EnumItem;
+    ASTGEN_MEMBERS_AstEnumItem;
     string name() const override { return m_name; }
     bool maybePointedTo() const override { return true; }
     bool hasDType() const override { return true; }
@@ -300,7 +300,7 @@ public:
         keyDTypep(keyDtp);
         dtypep(dtp);
     }
-    ASTGEN_MEMBERS_AssocArrayDType;
+    ASTGEN_MEMBERS_AstAssocArrayDType;
     const char* broken() const override {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep())));
@@ -385,7 +385,7 @@ private:
               AstRange* rangep);
 
 public:
-    ASTGEN_MEMBERS_BasicDType;
+    ASTGEN_MEMBERS_AstBasicDType;
     void dump(std::ostream& str) const override;
     // width/widthMin/numeric compared elsewhere
     bool same(const AstNode* samep) const override {
@@ -467,7 +467,7 @@ public:
         this->childDTypep(childDTypep);
         this->elementsp(elementsp);
     }
-    ASTGEN_MEMBERS_BracketArrayDType;
+    ASTGEN_MEMBERS_AstBracketArrayDType;
     bool similarDType(AstNodeDType* samep) const override { V3ERROR_NA_RETURN(false); }
     AstNodeDType* subDTypep() const override { return childDTypep(); }
     // METHODS
@@ -495,7 +495,7 @@ public:
         this->dtypep(this);
         this->addParamsp(paramsp);
     }
-    ASTGEN_MEMBERS_ClassRefDType;
+    ASTGEN_MEMBERS_AstClassRefDType;
     // METHODS
     const char* broken() const override;
     void cloneRelink() override;
@@ -539,7 +539,7 @@ public:
         dtypep(nullptr);  // V3Width will resolve
         widthFromSub(subDTypep());
     }
-    ASTGEN_MEMBERS_ConstDType;
+    ASTGEN_MEMBERS_AstConstDType;
     const char* broken() const override {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep())));
@@ -593,7 +593,7 @@ public:
         childDTypep(dtp);  // Only for parser
         dtypep(nullptr);  // V3Width will resolve
     }
-    ASTGEN_MEMBERS_DefImplicitDType;
+    ASTGEN_MEMBERS_AstDefImplicitDType;
     int uniqueNum() const { return m_uniqueNum; }
     bool same(const AstNode* samep) const override {
         const AstDefImplicitDType* const sp = static_cast<const AstDefImplicitDType*>(samep);
@@ -635,7 +635,7 @@ public:
         refDTypep(dtp);
         dtypep(nullptr);  // V3Width will resolve
     }
-    ASTGEN_MEMBERS_DynArrayDType;
+    ASTGEN_MEMBERS_AstDynArrayDType;
     const char* broken() const override {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep())));
@@ -677,7 +677,7 @@ public:
         : ASTGEN_SUPER_EmptyQueueDType(fl) {
         dtypep(this);
     }
-    ASTGEN_MEMBERS_EmptyQueueDType;
+    ASTGEN_MEMBERS_AstEmptyQueueDType;
     void dumpSmall(std::ostream& str) const override;
     bool hasDType() const override { return true; }
     bool maybePointedTo() const override { return true; }
@@ -716,7 +716,7 @@ public:
         dtypep(nullptr);  // V3Width will resolve
         widthFromSub(subDTypep());
     }
-    ASTGEN_MEMBERS_EnumDType;
+    ASTGEN_MEMBERS_AstEnumDType;
     const char* broken() const override {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep())));
@@ -777,7 +777,7 @@ public:
         , m_cellName{cellName}
         , m_ifaceName{ifaceName}
         , m_modportName{modport} {}
-    ASTGEN_MEMBERS_IfaceRefDType;
+    ASTGEN_MEMBERS_AstIfaceRefDType;
     // METHODS
     const char* broken() const override;
     void dump(std::ostream& str = std::cout) const override;
@@ -832,7 +832,7 @@ public:
         dtypep(this);
         widthFromSub(subDTypep());
     }
-    ASTGEN_MEMBERS_MemberDType;
+    ASTGEN_MEMBERS_AstMemberDType;
     string name() const override { return m_name; }  // * = Var name
     bool hasDType() const override { return true; }
     bool maybePointedTo() const override { return true; }
@@ -889,7 +889,7 @@ public:
         childDTypep(dtp);  // Only for parser
         dtypep(nullptr);  // V3Width will resolve
     }
-    ASTGEN_MEMBERS_ParamTypeDType;
+    ASTGEN_MEMBERS_AstParamTypeDType;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
     AstNodeDType* subDTypep() const override { return dtypep() ? dtypep() : childDTypep(); }
     AstBasicDType* basicp() const override { return subDTypep()->basicp(); }
@@ -923,7 +923,7 @@ class AstParseTypeDType final : public AstNodeDType {
 public:
     explicit AstParseTypeDType(FileLine* fl)
         : ASTGEN_SUPER_ParseTypeDType(fl) {}
-    ASTGEN_MEMBERS_ParseTypeDType;
+    ASTGEN_MEMBERS_AstParseTypeDType;
     AstNodeDType* dtypep() const { return nullptr; }
     // METHODS
     bool similarDType(AstNodeDType* samep) const override { return this == samep; }
@@ -960,7 +960,7 @@ public:
         refDTypep(dtp);
         dtypep(dtp);
     }
-    ASTGEN_MEMBERS_QueueDType;
+    ASTGEN_MEMBERS_AstQueueDType;
     const char* broken() const override {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep())));
@@ -1026,7 +1026,7 @@ public:
         : ASTGEN_SUPER_RefDType(fl) {
         this->typeofp(typeofp);
     }
-    ASTGEN_MEMBERS_RefDType;
+    ASTGEN_MEMBERS_AstRefDType;
     // METHODS
     const char* broken() const override;
     void cloneRelink() override;
@@ -1101,7 +1101,7 @@ public:
         refDTypep(nullptr);
         dtypep(nullptr);  // V3Width will resolve
     }
-    ASTGEN_MEMBERS_UnsizedArrayDType;
+    ASTGEN_MEMBERS_AstUnsizedArrayDType;
     const char* broken() const override {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep())));
@@ -1134,7 +1134,7 @@ public:
         : ASTGEN_SUPER_VoidDType(fl) {
         dtypep(this);
     }
-    ASTGEN_MEMBERS_VoidDType;
+    ASTGEN_MEMBERS_AstVoidDType;
     void dumpSmall(std::ostream& str) const override;
     bool hasDType() const override { return true; }
     bool maybePointedTo() const override { return true; }
@@ -1166,7 +1166,7 @@ public:
         refDTypep(nullptr);
         dtypep(nullptr);  // V3Width will resolve
     }
-    ASTGEN_MEMBERS_WildcardArrayDType;
+    ASTGEN_MEMBERS_AstWildcardArrayDType;
     const char* broken() const override {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep())));
@@ -1199,7 +1199,7 @@ class AstPackArrayDType final : public AstNodeArrayDType {
 public:
     inline AstPackArrayDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp, AstRange* rangep);
     inline AstPackArrayDType(FileLine* fl, AstNodeDType* dtp, AstRange* rangep);
-    ASTGEN_MEMBERS_PackArrayDType;
+    ASTGEN_MEMBERS_AstPackArrayDType;
     string prettyDTypeName() const override;
     bool isCompound() const override { return false; }
 };
@@ -1226,7 +1226,7 @@ public:
         // width and signing from the subDType/base type
         widthFromSub(subDTypep());
     }
-    ASTGEN_MEMBERS_UnpackArrayDType;
+    ASTGEN_MEMBERS_AstUnpackArrayDType;
     string prettyDTypeName() const override;
     bool same(const AstNode* samep) const override {
         const AstUnpackArrayDType* const sp = static_cast<const AstUnpackArrayDType*>(samep);
@@ -1244,7 +1244,7 @@ public:
     // VSigning below is mispurposed to indicate if packed or not
     AstStructDType(FileLine* fl, VSigning numericUnpack)
         : ASTGEN_SUPER_StructDType(fl, numericUnpack) {}
-    ASTGEN_MEMBERS_StructDType;
+    ASTGEN_MEMBERS_AstStructDType;
     string verilogKwd() const override { return "struct"; }
 };
 class AstUnionDType final : public AstNodeUOrStructDType {
@@ -1253,7 +1253,7 @@ public:
     // VSigning below is mispurposed to indicate if packed or not
     AstUnionDType(FileLine* fl, VSigning numericUnpack)
         : ASTGEN_SUPER_UnionDType(fl, numericUnpack) {}
-    ASTGEN_MEMBERS_UnionDType;
+    ASTGEN_MEMBERS_AstUnionDType;
     string verilogKwd() const override { return "union"; }
 };
 
diff --git a/src/V3AstNodeMath.h b/src/V3AstNodeMath.h
index 977a49b96..dc2d6f8ad 100644
--- a/src/V3AstNodeMath.h
+++ b/src/V3AstNodeMath.h
@@ -44,7 +44,7 @@ protected:
         : AstNode{t, fl} {}
 
 public:
-    ASTGEN_MEMBERS_NodeMath;
+    ASTGEN_MEMBERS_AstNodeMath;
     // METHODS
     void dump(std::ostream& str) const override;
     bool hasDType() const override { return true; }
@@ -70,7 +70,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeBiop;
+    ASTGEN_MEMBERS_AstNodeBiop;
     // Clone single node, just get same type back.
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) = 0;
     // METHODS
@@ -94,7 +94,7 @@ protected:
         : AstNodeBiop{t, fl, lhs, rhs} {}
 
 public:
-    ASTGEN_MEMBERS_NodeBiCom;
+    ASTGEN_MEMBERS_AstNodeBiCom;
 };
 class AstNodeBiComAsv VL_NOT_FINAL : public AstNodeBiCom {
     // Binary math with commutative & associative properties
@@ -103,7 +103,7 @@ protected:
         : AstNodeBiCom{t, fl, lhs, rhs} {}
 
 public:
-    ASTGEN_MEMBERS_NodeBiComAsv;
+    ASTGEN_MEMBERS_AstNodeBiComAsv;
 };
 class AstNodeSel VL_NOT_FINAL : public AstNodeBiop {
     // Single bit range extraction, perhaps with non-constant selection or array selection
@@ -114,7 +114,7 @@ protected:
         : AstNodeBiop{t, fl, fromp, bitp} {}
 
 public:
-    ASTGEN_MEMBERS_NodeSel;
+    ASTGEN_MEMBERS_AstNodeSel;
     int bitConst() const;
     bool hasDType() const override { return true; }
 };
@@ -127,7 +127,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeStream;
+    ASTGEN_MEMBERS_AstNodeStream;
 };
 class AstNodeSystemBiop VL_NOT_FINAL : public AstNodeBiop {
 public:
@@ -135,7 +135,7 @@ public:
         : AstNodeBiop(t, fl, lhsp, rhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_NodeSystemBiop;
+    ASTGEN_MEMBERS_AstNodeSystemBiop;
     bool cleanOut() const override { return false; }
     bool cleanLhs() const override { return false; }
     bool cleanRhs() const override { return false; }
@@ -161,7 +161,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeQuadop;
+    ASTGEN_MEMBERS_AstNodeQuadop;
     // METHODS
     // Set out to evaluation of a AstConst'ed
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
@@ -185,7 +185,7 @@ protected:
         : AstNodeMath{t, fl} {}
 
 public:
-    ASTGEN_MEMBERS_NodeTermop;
+    ASTGEN_MEMBERS_AstNodeTermop;
     // Know no children, and hot function, so skip iterator for speed
     // cppcheck-suppress functionConst
     void iterateChildren(VNVisitor& v) {}
@@ -205,7 +205,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeTriop;
+    ASTGEN_MEMBERS_AstNodeTriop;
     // METHODS
     void dump(std::ostream& str) const override;
     // Set out to evaluation of a AstConst'ed
@@ -236,7 +236,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeCond;
+    ASTGEN_MEMBERS_AstNodeCond;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
                        const V3Number& ths) override;
     string emitVerilog() override { return "%k(%l %f? %r %k: %t)"; }
@@ -262,7 +262,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeUniop;
+    ASTGEN_MEMBERS_AstNodeUniop;
     // METHODS
     void dump(std::ostream& str) const override;
     // Set out to evaluation of a AstConst'ed lhs
@@ -282,7 +282,7 @@ public:
         : AstNodeUniop(t, fl, lhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_NodeSystemUniop;
+    ASTGEN_MEMBERS_AstNodeSystemUniop;
     bool cleanOut() const override { return true; }
     bool cleanLhs() const override { return false; }
     bool sizeMattersLhs() const override { return false; }
@@ -315,7 +315,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeVarRef;
+    ASTGEN_MEMBERS_AstNodeVarRef;
     void dump(std::ostream& str) const override;
     bool hasDType() const override { return true; }
     const char* broken() const override;
@@ -358,7 +358,7 @@ public:
     }
 
 public:
-    ASTGEN_MEMBERS_AddrOfCFunc;
+    ASTGEN_MEMBERS_AstAddrOfCFunc;
     void cloneRelink() override;
     const char* broken() const override;
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
@@ -381,7 +381,7 @@ public:
         dtypeFrom(exprsp);
     }
     inline AstCMath(FileLine* fl, const string& textStmt, int setwidth, bool cleanOut = true);
-    ASTGEN_MEMBERS_CMath;
+    ASTGEN_MEMBERS_AstCMath;
     bool isGateOptimizable() const override { return m_pure; }
     bool isPredictOptimizable() const override { return m_pure; }
     bool cleanOut() const override { return m_cleanOut; }
@@ -399,7 +399,7 @@ public:
         : ASTGEN_SUPER_ConsAssoc(fl) {
         this->defaultp(defaultp);
     }
-    ASTGEN_MEMBERS_ConsAssoc;
+    ASTGEN_MEMBERS_AstConsAssoc;
     string emitVerilog() override { return "'{}"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -417,7 +417,7 @@ public:
         this->lhsp(lhsp);
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_ConsDynArray;
+    ASTGEN_MEMBERS_AstConsDynArray;
     string emitVerilog() override { return "'{%l, %r}"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -435,7 +435,7 @@ public:
         this->lhsp(lhsp);
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_ConsQueue;
+    ASTGEN_MEMBERS_AstConsQueue;
     string emitVerilog() override { return "'{%l, %r}"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -451,7 +451,7 @@ public:
         : ASTGEN_SUPER_ConsWildcard(fl) {
         this->defaultp(defaultp);
     }
-    ASTGEN_MEMBERS_ConsWildcard;
+    ASTGEN_MEMBERS_AstConsWildcard;
     string emitVerilog() override { return "'{}"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -572,7 +572,7 @@ public:
         dtypeSetBit();  // Events 1 bit, objects 64 bits, so autoExtend=1 and use bit here
         initWithNumber();
     }
-    ASTGEN_MEMBERS_Const;
+    ASTGEN_MEMBERS_AstConst;
     string name() const override { return num().ascii(); }  // * = Value
     const V3Number& num() const { return m_num; }  // * = Value
     V3Number& num() { return m_num; }  // * = Value
@@ -597,7 +597,7 @@ class AstEmptyQueue final : public AstNodeMath {
 public:
     explicit AstEmptyQueue(FileLine* fl)
         : ASTGEN_SUPER_EmptyQueue(fl) {}
-    ASTGEN_MEMBERS_EmptyQueue;
+    ASTGEN_MEMBERS_AstEmptyQueue;
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitVerilog() override { return "{}"; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -614,7 +614,7 @@ public:
         , m_classOrPackagep{classOrPackagep} {
         dtypeFrom(m_itemp);
     }
-    ASTGEN_MEMBERS_EnumItemRef;
+    ASTGEN_MEMBERS_AstEnumItemRef;
     void dump(std::ostream& str) const override;
     string name() const override { return itemp()->name(); }
     int instrCount() const override { return 0; }
@@ -646,7 +646,7 @@ public:
         this->resultp(resultp);
         dtypeFrom(resultp);
     }
-    ASTGEN_MEMBERS_ExprStmt;
+    ASTGEN_MEMBERS_AstExprStmt;
     // METHODS
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -662,7 +662,7 @@ public:
         this->filep(filep);
         this->strp(strp);
     }
-    ASTGEN_MEMBERS_FError;
+    ASTGEN_MEMBERS_AstFError;
     string emitVerilog() override { return "%f$ferror(%l, %r)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return true; }
@@ -685,7 +685,7 @@ public:
         this->startp(startp);
         this->countp(countp);
     }
-    ASTGEN_MEMBERS_FRead;
+    ASTGEN_MEMBERS_AstFRead;
     string verilogKwd() const override { return "$fread"; }
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -704,7 +704,7 @@ public:
         : ASTGEN_SUPER_FRewind(fl) {
         this->filep(filep);
     }
-    ASTGEN_MEMBERS_FRewind;
+    ASTGEN_MEMBERS_AstFRewind;
     string verilogKwd() const override { return "$frewind"; }
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -729,7 +729,7 @@ public:
         addExprsp(exprsp);
         this->filep(filep);
     }
-    ASTGEN_MEMBERS_FScanF;
+    ASTGEN_MEMBERS_AstFScanF;
     string name() const override { return m_text; }
     string verilogKwd() const override { return "$fscanf"; }
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
@@ -756,7 +756,7 @@ public:
         this->offset(offset);
         this->operation(operation);
     }
-    ASTGEN_MEMBERS_FSeek;
+    ASTGEN_MEMBERS_AstFSeek;
     string verilogKwd() const override { return "$fseek"; }
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -775,7 +775,7 @@ public:
         : ASTGEN_SUPER_FTell(fl) {
         this->filep(filep);
     }
-    ASTGEN_MEMBERS_FTell;
+    ASTGEN_MEMBERS_AstFTell;
     string verilogKwd() const override { return "$ftell"; }
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -796,7 +796,7 @@ public:
         : ASTGEN_SUPER_Fell(fl) {
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_Fell;
+    ASTGEN_MEMBERS_AstFell;
     string emitVerilog() override { return "$fell(%l)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -814,7 +814,7 @@ public:
         this->exprp(exprp);
         this->rangep(rangep);
     }
-    ASTGEN_MEMBERS_GatePin;
+    ASTGEN_MEMBERS_AstGatePin;
     string emitVerilog() override { return "%l"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return true; }
@@ -830,7 +830,7 @@ public:
         this->lhsp(lhsp);
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_Implication;
+    ASTGEN_MEMBERS_AstImplication;
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -848,7 +848,7 @@ public:
         this->addItemsp(itemsp);
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_Inside;
+    ASTGEN_MEMBERS_AstInside;
     string emitVerilog() override { return "%l inside { %r }"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return false; }  // NA
@@ -862,7 +862,7 @@ public:
         this->lhsp(lhsp);
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_InsideRange;
+    ASTGEN_MEMBERS_AstInsideRange;
     string emitVerilog() override { return "[%l:%r]"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return false; }  // NA
@@ -882,7 +882,7 @@ public:
         : ASTGEN_SUPER_LambdaArgRef(fl)
         , m_name{name}
         , m_index(index) {}
-    ASTGEN_MEMBERS_LambdaArgRef;
+    ASTGEN_MEMBERS_AstLambdaArgRef;
     bool same(const AstNode* /*samep*/) const override { return true; }
     string emitVerilog() override { return name(); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -913,7 +913,7 @@ public:
         this->fromp(fromp);
         dtypep(dtp);
     }
-    ASTGEN_MEMBERS_MemberSel;
+    ASTGEN_MEMBERS_AstMemberSel;
     void cloneRelink() override;
     const char* broken() const override;
     void dump(std::ostream& str) const override;
@@ -936,7 +936,7 @@ public:
         dtypeFrom(rhsp);  // otherwise V3Width will resolve
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_NewCopy;
+    ASTGEN_MEMBERS_AstNewCopy;
     string emitVerilog() override { return "new"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return true; }
@@ -955,7 +955,7 @@ public:
         this->sizep(sizep);
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_NewDynamic;
+    ASTGEN_MEMBERS_AstNewDynamic;
     string emitVerilog() override { return "new"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return true; }
@@ -973,7 +973,7 @@ public:
         this->exprp(exprp);
         this->ticksp(ticksp);
     }
-    ASTGEN_MEMBERS_Past;
+    ASTGEN_MEMBERS_AstPast;
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -999,7 +999,7 @@ public:
         this->keyp(keyp);
         this->repp(repp);
     }
-    ASTGEN_MEMBERS_PatMember;
+    ASTGEN_MEMBERS_AstPatMember;
     string emitVerilog() override { return lhssp() ? "%f{%r{%k%l}}" : "%l"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -1020,7 +1020,7 @@ public:
         : ASTGEN_SUPER_Pattern(fl) {
         addItemsp(itemsp);
     }
-    ASTGEN_MEMBERS_Pattern;
+    ASTGEN_MEMBERS_AstPattern;
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -1048,7 +1048,7 @@ public:
         , m_urandom{urandom} {
         this->seedp(seedp);
     }
-    ASTGEN_MEMBERS_Rand;
+    ASTGEN_MEMBERS_AstRand;
     string emitVerilog() override {
         return seedp() ? (m_urandom ? "%f$urandom(%l)" : "%f$random(%l)")
                        : (m_urandom ? "%f$urandom()" : "%f$random()");
@@ -1081,7 +1081,7 @@ public:
         : ASTGEN_SUPER_Rose(fl) {
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_Rose;
+    ASTGEN_MEMBERS_AstRose;
     string emitVerilog() override { return "$rose(%l)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -1102,7 +1102,7 @@ public:
         this->addExprsp(exprsp);
         this->fromp(fromp);
     }
-    ASTGEN_MEMBERS_SScanF;
+    ASTGEN_MEMBERS_AstSScanF;
     string name() const override { return m_text; }
     string verilogKwd() const override { return "$sscanf"; }
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
@@ -1126,7 +1126,7 @@ public:
         : ASTGEN_SUPER_Sampled(fl) {
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_Sampled;
+    ASTGEN_MEMBERS_AstSampled;
     string emitVerilog() override { return "$sampled(%l)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -1152,7 +1152,7 @@ public:
         , m_forFormat{forFormat} {
         dtypeSetUInt64();
     }
-    ASTGEN_MEMBERS_ScopeName;
+    ASTGEN_MEMBERS_AstScopeName;
     bool same(const AstNode* samep) const override {
         return (m_dpiExport == static_cast<const AstScopeName*>(samep)->m_dpiExport
                 && m_forFormat == static_cast<const AstScopeName*>(samep)->m_forFormat);
@@ -1190,7 +1190,7 @@ public:
         this->keyp(keyp);
         this->valuep(valuep);
     }
-    ASTGEN_MEMBERS_SetAssoc;
+    ASTGEN_MEMBERS_AstSetAssoc;
     string emitVerilog() override { return "'{}"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -1211,7 +1211,7 @@ public:
         this->keyp(keyp);
         this->valuep(valuep);
     }
-    ASTGEN_MEMBERS_SetWildcard;
+    ASTGEN_MEMBERS_AstSetWildcard;
     string emitVerilog() override { return "'{}"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -1228,7 +1228,7 @@ public:
         : ASTGEN_SUPER_Stable(fl) {
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_Stable;
+    ASTGEN_MEMBERS_AstStable;
     string emitVerilog() override { return "$stable(%l)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); }
@@ -1244,7 +1244,7 @@ public:
         : ASTGEN_SUPER_SystemF(fl) {
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_SystemF;
+    ASTGEN_MEMBERS_AstSystemF;
     string verilogKwd() const override { return "$system"; }
     string emitVerilog() override { return verilogKwd(); }
     string emitC() override { return "VL_SYSTEM_%nq(%lw, %P)"; }
@@ -1264,7 +1264,7 @@ public:
         : ASTGEN_SUPER_TestPlusArgs(fl) {
         this->searchp(searchp);
     }
-    ASTGEN_MEMBERS_TestPlusArgs;
+    ASTGEN_MEMBERS_AstTestPlusArgs;
     string verilogKwd() const override { return "$test$plusargs"; }
     string emitVerilog() override { return verilogKwd(); }
     string emitC() override { return "VL_VALUEPLUSARGS_%nq(%lw, %P, nullptr)"; }
@@ -1282,7 +1282,7 @@ public:
         : ASTGEN_SUPER_UCFunc(fl) {
         this->addExprsp(exprsp);
     }
-    ASTGEN_MEMBERS_UCFunc;
+    ASTGEN_MEMBERS_AstUCFunc;
     bool cleanOut() const override { return false; }
     string emitVerilog() override { V3ERROR_NA_RETURN(""); }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -1302,7 +1302,7 @@ public:
         : ASTGEN_SUPER_Unbounded(fl) {
         dtypeSetSigned32();
     }
-    ASTGEN_MEMBERS_Unbounded;
+    ASTGEN_MEMBERS_AstUnbounded;
     string emitVerilog() override { return "$"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return true; }
@@ -1317,7 +1317,7 @@ public:
         this->searchp(searchp);
         this->outp(outp);
     }
-    ASTGEN_MEMBERS_ValuePlusArgs;
+    ASTGEN_MEMBERS_AstValuePlusArgs;
     string verilogKwd() const override { return "$value$plusargs"; }
     string emitVerilog() override { return "%f$value$plusargs(%l, %k%r)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -1338,7 +1338,7 @@ public:
         : ASTGEN_SUPER_BufIf1(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_BufIf1;
+    ASTGEN_MEMBERS_AstBufIf1;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstBufIf1(this->fileline(), lhsp, rhsp);
     }
@@ -1365,7 +1365,7 @@ class AstCastDynamic final : public AstNodeBiop {
 public:
     AstCastDynamic(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_CastDynamic(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_CastDynamic;
+    ASTGEN_MEMBERS_AstCastDynamic;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         V3ERROR_NA;
     }
@@ -1394,7 +1394,7 @@ public:
         , m_ignoreCase{ignoreCase} {
         dtypeSetUInt32();
     }
-    ASTGEN_MEMBERS_CompareNN;
+    ASTGEN_MEMBERS_AstCompareNN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstCompareNN(this->fileline(), lhsp, rhsp, m_ignoreCase);
     }
@@ -1425,7 +1425,7 @@ public:
                                VSigning::UNSIGNED);
         }
     }
-    ASTGEN_MEMBERS_Concat;
+    ASTGEN_MEMBERS_AstConcat;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstConcat(this->fileline(), lhsp, rhsp);
     }
@@ -1448,7 +1448,7 @@ public:
         : ASTGEN_SUPER_ConcatN(fl, lhsp, rhsp) {
         dtypeSetString();
     }
-    ASTGEN_MEMBERS_ConcatN;
+    ASTGEN_MEMBERS_AstConcatN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstConcatN(this->fileline(), lhsp, rhsp);
     }
@@ -1471,7 +1471,7 @@ public:
         : ASTGEN_SUPER_Div(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Div;
+    ASTGEN_MEMBERS_AstDiv;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstDiv(this->fileline(), lhsp, rhsp);
     }
@@ -1493,7 +1493,7 @@ public:
         : ASTGEN_SUPER_DivD(fl, lhsp, rhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_DivD;
+    ASTGEN_MEMBERS_AstDivD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstDivD(this->fileline(), lhsp, rhsp);
     }
@@ -1517,7 +1517,7 @@ public:
         : ASTGEN_SUPER_DivS(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_DivS;
+    ASTGEN_MEMBERS_AstDivS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstDivS(this->fileline(), lhsp, rhsp);
     }
@@ -1541,7 +1541,7 @@ public:
         : ASTGEN_SUPER_EqWild(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_EqWild;
+    ASTGEN_MEMBERS_AstEqWild;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstEqWild(this->fileline(), lhsp, rhsp);
     }
@@ -1563,7 +1563,7 @@ class AstFGetS final : public AstNodeBiop {
 public:
     AstFGetS(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_FGetS(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_FGetS;
+    ASTGEN_MEMBERS_AstFGetS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstFGetS(this->fileline(), lhsp, rhsp);
     }
@@ -1588,7 +1588,7 @@ class AstFUngetC final : public AstNodeBiop {
 public:
     AstFUngetC(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_FUngetC(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_FUngetC;
+    ASTGEN_MEMBERS_AstFUngetC;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         V3ERROR_NA;
     }
@@ -1617,7 +1617,7 @@ public:
         : ASTGEN_SUPER_GetcN(fl, lhsp, rhsp) {
         dtypeSetBitSized(8, VSigning::UNSIGNED);
     }
-    ASTGEN_MEMBERS_GetcN;
+    ASTGEN_MEMBERS_AstGetcN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGetcN(this->fileline(), lhsp, rhsp);
     }
@@ -1642,7 +1642,7 @@ public:
         : ASTGEN_SUPER_GetcRefN(fl, lhsp, rhsp) {
         dtypeSetBitSized(8, VSigning::UNSIGNED);
     }
-    ASTGEN_MEMBERS_GetcRefN;
+    ASTGEN_MEMBERS_AstGetcRefN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGetcRefN(this->fileline(), lhsp, rhsp);
     }
@@ -1664,7 +1664,7 @@ public:
         : ASTGEN_SUPER_Gt(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_Gt;
+    ASTGEN_MEMBERS_AstGt;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGt(this->fileline(), lhsp, rhsp);
     }
@@ -1686,7 +1686,7 @@ public:
         : ASTGEN_SUPER_GtD(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_GtD;
+    ASTGEN_MEMBERS_AstGtD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGtD(this->fileline(), lhsp, rhsp);
     }
@@ -1710,7 +1710,7 @@ public:
         : ASTGEN_SUPER_GtN(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_GtN;
+    ASTGEN_MEMBERS_AstGtN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGtN(this->fileline(), lhsp, rhsp);
     }
@@ -1734,7 +1734,7 @@ public:
         : ASTGEN_SUPER_GtS(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_GtS;
+    ASTGEN_MEMBERS_AstGtS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGtS(this->fileline(), lhsp, rhsp);
     }
@@ -1757,7 +1757,7 @@ public:
         : ASTGEN_SUPER_Gte(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_Gte;
+    ASTGEN_MEMBERS_AstGte;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGte(this->fileline(), lhsp, rhsp);
     }
@@ -1779,7 +1779,7 @@ public:
         : ASTGEN_SUPER_GteD(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_GteD;
+    ASTGEN_MEMBERS_AstGteD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGteD(this->fileline(), lhsp, rhsp);
     }
@@ -1803,7 +1803,7 @@ public:
         : ASTGEN_SUPER_GteN(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_GteN;
+    ASTGEN_MEMBERS_AstGteN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGteN(this->fileline(), lhsp, rhsp);
     }
@@ -1827,7 +1827,7 @@ public:
         : ASTGEN_SUPER_GteS(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_GteS;
+    ASTGEN_MEMBERS_AstGteS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstGteS(this->fileline(), lhsp, rhsp);
     }
@@ -1850,7 +1850,7 @@ public:
         : ASTGEN_SUPER_LogAnd(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LogAnd;
+    ASTGEN_MEMBERS_AstLogAnd;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLogAnd(this->fileline(), lhsp, rhsp);
     }
@@ -1873,7 +1873,7 @@ public:
         : ASTGEN_SUPER_LogIf(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LogIf;
+    ASTGEN_MEMBERS_AstLogIf;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLogIf(this->fileline(), lhsp, rhsp);
     }
@@ -1901,7 +1901,7 @@ public:
         : ASTGEN_SUPER_LogOr(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LogOr;
+    ASTGEN_MEMBERS_AstLogOr;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLogOr(this->fileline(), lhsp, rhsp);
     }
@@ -1932,7 +1932,7 @@ public:
         : ASTGEN_SUPER_Lt(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_Lt;
+    ASTGEN_MEMBERS_AstLt;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLt(this->fileline(), lhsp, rhsp);
     }
@@ -1954,7 +1954,7 @@ public:
         : ASTGEN_SUPER_LtD(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LtD;
+    ASTGEN_MEMBERS_AstLtD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLtD(this->fileline(), lhsp, rhsp);
     }
@@ -1978,7 +1978,7 @@ public:
         : ASTGEN_SUPER_LtN(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LtN;
+    ASTGEN_MEMBERS_AstLtN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLtN(this->fileline(), lhsp, rhsp);
     }
@@ -2002,7 +2002,7 @@ public:
         : ASTGEN_SUPER_LtS(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LtS;
+    ASTGEN_MEMBERS_AstLtS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLtS(this->fileline(), lhsp, rhsp);
     }
@@ -2025,7 +2025,7 @@ public:
         : ASTGEN_SUPER_Lte(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_Lte;
+    ASTGEN_MEMBERS_AstLte;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLte(this->fileline(), lhsp, rhsp);
     }
@@ -2047,7 +2047,7 @@ public:
         : ASTGEN_SUPER_LteD(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LteD;
+    ASTGEN_MEMBERS_AstLteD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLteD(this->fileline(), lhsp, rhsp);
     }
@@ -2071,7 +2071,7 @@ public:
         : ASTGEN_SUPER_LteN(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LteN;
+    ASTGEN_MEMBERS_AstLteN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLteN(this->fileline(), lhsp, rhsp);
     }
@@ -2095,7 +2095,7 @@ public:
         : ASTGEN_SUPER_LteS(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LteS;
+    ASTGEN_MEMBERS_AstLteS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLteS(this->fileline(), lhsp, rhsp);
     }
@@ -2118,7 +2118,7 @@ public:
         : ASTGEN_SUPER_ModDiv(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_ModDiv;
+    ASTGEN_MEMBERS_AstModDiv;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstModDiv(this->fileline(), lhsp, rhsp);
     }
@@ -2140,7 +2140,7 @@ public:
         : ASTGEN_SUPER_ModDivS(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_ModDivS;
+    ASTGEN_MEMBERS_AstModDivS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstModDivS(this->fileline(), lhsp, rhsp);
     }
@@ -2163,7 +2163,7 @@ public:
         : ASTGEN_SUPER_NeqWild(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_NeqWild;
+    ASTGEN_MEMBERS_AstNeqWild;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstNeqWild(this->fileline(), lhsp, rhsp);
     }
@@ -2185,7 +2185,7 @@ public:
         : ASTGEN_SUPER_Pow(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Pow;
+    ASTGEN_MEMBERS_AstPow;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstPow(this->fileline(), lhsp, rhsp);
     }
@@ -2208,7 +2208,7 @@ public:
         : ASTGEN_SUPER_PowD(fl, lhsp, rhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_PowD;
+    ASTGEN_MEMBERS_AstPowD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstPowD(this->fileline(), lhsp, rhsp);
     }
@@ -2231,7 +2231,7 @@ public:
         : ASTGEN_SUPER_PowSS(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_PowSS;
+    ASTGEN_MEMBERS_AstPowSS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstPowSS(this->fileline(), lhsp, rhsp);
     }
@@ -2255,7 +2255,7 @@ public:
         : ASTGEN_SUPER_PowSU(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_PowSU;
+    ASTGEN_MEMBERS_AstPowSU;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstPowSU(this->fileline(), lhsp, rhsp);
     }
@@ -2279,7 +2279,7 @@ public:
         : ASTGEN_SUPER_PowUS(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_PowUS;
+    ASTGEN_MEMBERS_AstPowUS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstPowUS(this->fileline(), lhsp, rhsp);
     }
@@ -2313,7 +2313,7 @@ public:
     }
     AstReplicate(FileLine* fl, AstNode* lhsp, uint32_t repCount)
         : AstReplicate(fl, lhsp, new AstConst(fl, repCount)) {}
-    ASTGEN_MEMBERS_Replicate;
+    ASTGEN_MEMBERS_AstReplicate;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstReplicate(this->fileline(), lhsp, rhsp);
     }
@@ -2338,7 +2338,7 @@ public:
     }
     AstReplicateN(FileLine* fl, AstNode* lhsp, uint32_t repCount)
         : AstReplicateN(fl, lhsp, new AstConst(fl, repCount)) {}
-    ASTGEN_MEMBERS_ReplicateN;
+    ASTGEN_MEMBERS_AstReplicateN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstReplicateN(this->fileline(), lhsp, rhsp);
     }
@@ -2361,7 +2361,7 @@ public:
         : ASTGEN_SUPER_ShiftL(fl, lhsp, rhsp) {
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED);
     }
-    ASTGEN_MEMBERS_ShiftL;
+    ASTGEN_MEMBERS_AstShiftL;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstShiftL(this->fileline(), lhsp, rhsp);
     }
@@ -2385,7 +2385,7 @@ public:
         : ASTGEN_SUPER_ShiftR(fl, lhsp, rhsp) {
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED);
     }
-    ASTGEN_MEMBERS_ShiftR;
+    ASTGEN_MEMBERS_AstShiftR;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstShiftR(this->fileline(), lhsp, rhsp);
     }
@@ -2413,7 +2413,7 @@ public:
         // Important that widthMin be correct, as opExtend requires it after V3Expand
         if (setwidth) dtypeSetLogicSized(setwidth, VSigning::SIGNED);
     }
-    ASTGEN_MEMBERS_ShiftRS;
+    ASTGEN_MEMBERS_AstShiftRS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstShiftRS(this->fileline(), lhsp, rhsp);
     }
@@ -2436,7 +2436,7 @@ public:
         : ASTGEN_SUPER_Sub(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Sub;
+    ASTGEN_MEMBERS_AstSub;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstSub(this->fileline(), lhsp, rhsp);
     }
@@ -2458,7 +2458,7 @@ public:
         : ASTGEN_SUPER_SubD(fl, lhsp, rhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_SubD;
+    ASTGEN_MEMBERS_AstSubD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstSubD(this->fileline(), lhsp, rhsp);
     }
@@ -2483,7 +2483,7 @@ public:
         : ASTGEN_SUPER_URandomRange(fl, lhsp, rhsp) {
         dtypeSetUInt32();  // Says IEEE
     }
-    ASTGEN_MEMBERS_URandomRange;
+    ASTGEN_MEMBERS_AstURandomRange;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstURandomRange(fileline(), lhsp, rhsp);
     }
@@ -2509,7 +2509,7 @@ public:
         : ASTGEN_SUPER_Eq(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_Eq;
+    ASTGEN_MEMBERS_AstEq;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstEq(this->fileline(), lhsp, rhsp);
     }
@@ -2533,7 +2533,7 @@ public:
         : ASTGEN_SUPER_EqCase(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_EqCase;
+    ASTGEN_MEMBERS_AstEqCase;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstEqCase(this->fileline(), lhsp, rhsp);
     }
@@ -2555,7 +2555,7 @@ public:
         : ASTGEN_SUPER_EqD(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_EqD;
+    ASTGEN_MEMBERS_AstEqD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstEqD(this->fileline(), lhsp, rhsp);
     }
@@ -2579,7 +2579,7 @@ public:
         : ASTGEN_SUPER_EqN(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_EqN;
+    ASTGEN_MEMBERS_AstEqN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstEqN(this->fileline(), lhsp, rhsp);
     }
@@ -2603,7 +2603,7 @@ public:
         : ASTGEN_SUPER_LogEq(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LogEq;
+    ASTGEN_MEMBERS_AstLogEq;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstLogEq(this->fileline(), lhsp, rhsp);
     }
@@ -2626,7 +2626,7 @@ public:
         : ASTGEN_SUPER_Neq(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_Neq;
+    ASTGEN_MEMBERS_AstNeq;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstNeq(this->fileline(), lhsp, rhsp);
     }
@@ -2648,7 +2648,7 @@ public:
         : ASTGEN_SUPER_NeqCase(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_NeqCase;
+    ASTGEN_MEMBERS_AstNeqCase;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstNeqCase(this->fileline(), lhsp, rhsp);
     }
@@ -2670,7 +2670,7 @@ public:
         : ASTGEN_SUPER_NeqD(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_NeqD;
+    ASTGEN_MEMBERS_AstNeqD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstNeqD(this->fileline(), lhsp, rhsp);
     }
@@ -2694,7 +2694,7 @@ public:
         : ASTGEN_SUPER_NeqN(fl, lhsp, rhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_NeqN;
+    ASTGEN_MEMBERS_AstNeqN;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstNeqN(this->fileline(), lhsp, rhsp);
     }
@@ -2720,7 +2720,7 @@ public:
         : ASTGEN_SUPER_Add(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Add;
+    ASTGEN_MEMBERS_AstAdd;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAdd(this->fileline(), lhsp, rhsp);
     }
@@ -2742,7 +2742,7 @@ public:
         : ASTGEN_SUPER_AddD(fl, lhsp, rhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_AddD;
+    ASTGEN_MEMBERS_AstAddD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAddD(this->fileline(), lhsp, rhsp);
     }
@@ -2766,7 +2766,7 @@ public:
         : ASTGEN_SUPER_And(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_And;
+    ASTGEN_MEMBERS_AstAnd;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAnd(this->fileline(), lhsp, rhsp);
     }
@@ -2788,7 +2788,7 @@ public:
         : ASTGEN_SUPER_Mul(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Mul;
+    ASTGEN_MEMBERS_AstMul;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstMul(this->fileline(), lhsp, rhsp);
     }
@@ -2811,7 +2811,7 @@ public:
         : ASTGEN_SUPER_MulD(fl, lhsp, rhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_MulD;
+    ASTGEN_MEMBERS_AstMulD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstMulD(this->fileline(), lhsp, rhsp);
     }
@@ -2835,7 +2835,7 @@ public:
         : ASTGEN_SUPER_MulS(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_MulS;
+    ASTGEN_MEMBERS_AstMulS;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstMulS(this->fileline(), lhsp, rhsp);
     }
@@ -2860,7 +2860,7 @@ public:
         : ASTGEN_SUPER_Or(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Or;
+    ASTGEN_MEMBERS_AstOr;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstOr(this->fileline(), lhsp, rhsp);
     }
@@ -2882,7 +2882,7 @@ public:
         : ASTGEN_SUPER_Xor(fl, lhsp, rhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Xor;
+    ASTGEN_MEMBERS_AstXor;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstXor(this->fileline(), lhsp, rhsp);
     }
@@ -2920,7 +2920,7 @@ public:
         : ASTGEN_SUPER_ArraySel(fl, fromp, new AstConst(fl, bit)) {
         init(fromp);
     }
-    ASTGEN_MEMBERS_ArraySel;
+    ASTGEN_MEMBERS_AstArraySel;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstArraySel(this->fileline(), lhsp, rhsp);
     }
@@ -2958,7 +2958,7 @@ public:
         : ASTGEN_SUPER_AssocSel(fl, fromp, bitp) {
         init(fromp);
     }
-    ASTGEN_MEMBERS_AssocSel;
+    ASTGEN_MEMBERS_AstAssocSel;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAssocSel(this->fileline(), lhsp, rhsp);
     }
@@ -2993,7 +2993,7 @@ public:
         : ASTGEN_SUPER_WildcardSel(fl, fromp, bitp) {
         init(fromp);
     }
-    ASTGEN_MEMBERS_WildcardSel;
+    ASTGEN_MEMBERS_AstWildcardSel;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstWildcardSel{this->fileline(), lhsp, rhsp};
     }
@@ -3019,7 +3019,7 @@ public:
         : ASTGEN_SUPER_WordSel(fl, fromp, bitp) {
         dtypeSetUInt32();  // Always used on WData arrays so returns edata size
     }
-    ASTGEN_MEMBERS_WordSel;
+    ASTGEN_MEMBERS_AstWordSel;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstWordSel(this->fileline(), lhsp, rhsp);
     }
@@ -3044,7 +3044,7 @@ class AstStreamL final : public AstNodeStream {
 public:
     AstStreamL(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_StreamL(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_StreamL;
+    ASTGEN_MEMBERS_AstStreamL;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstStreamL(this->fileline(), lhsp, rhsp);
     }
@@ -3065,7 +3065,7 @@ class AstStreamR final : public AstNodeStream {
 public:
     AstStreamR(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_StreamR(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_StreamR;
+    ASTGEN_MEMBERS_AstStreamR;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstStreamR(this->fileline(), lhsp, rhsp);
     }
@@ -3087,7 +3087,7 @@ class AstAtan2D final : public AstNodeSystemBiop {
 public:
     AstAtan2D(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_Atan2D(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_Atan2D;
+    ASTGEN_MEMBERS_AstAtan2D;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAtan2D(this->fileline(), lhsp, rhsp);
     }
@@ -3101,7 +3101,7 @@ class AstHypotD final : public AstNodeSystemBiop {
 public:
     AstHypotD(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_HypotD(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_HypotD;
+    ASTGEN_MEMBERS_AstHypotD;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstHypotD(this->fileline(), lhsp, rhsp);
     }
@@ -3123,7 +3123,7 @@ public:
         : ASTGEN_SUPER_CountBits(fl, exprp, ctrl1p, ctrl2p, ctrl2p->cloneTree(false)) {}
     AstCountBits(FileLine* fl, AstNode* exprp, AstNode* ctrl1p, AstNode* ctrl2p, AstNode* ctrl3p)
         : ASTGEN_SUPER_CountBits(fl, exprp, ctrl1p, ctrl2p, ctrl3p) {}
-    ASTGEN_MEMBERS_CountBits;
+    ASTGEN_MEMBERS_AstCountBits;
     void numberOperate(V3Number& out, const V3Number& expr, const V3Number& ctrl1,
                        const V3Number& ctrl2, const V3Number& ctrl3) override {
         out.opCountBits(expr, ctrl1, ctrl2, ctrl3);
@@ -3151,7 +3151,7 @@ public:
         , m_timeunit{timeunit} {
         dtypeSetUInt64();
     }
-    ASTGEN_MEMBERS_Time;
+    ASTGEN_MEMBERS_AstTime;
     string emitVerilog() override { return "%f$time"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return true; }
@@ -3171,7 +3171,7 @@ public:
         , m_timeunit{timeunit} {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_TimeD;
+    ASTGEN_MEMBERS_AstTimeD;
     string emitVerilog() override { return "%f$realtime"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return true; }
@@ -3194,7 +3194,7 @@ class AstPostAdd final : public AstNodeTriop {
 public:
     AstPostAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
         : ASTGEN_SUPER_PostAdd(fl, lhsp, rhsp, thsp) {}
-    ASTGEN_MEMBERS_PostAdd;
+    ASTGEN_MEMBERS_AstPostAdd;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
                        const V3Number& ths) override {
         V3ERROR_NA;  // Need to modify lhs
@@ -3219,7 +3219,7 @@ class AstPostSub final : public AstNodeTriop {
 public:
     AstPostSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
         : ASTGEN_SUPER_PostSub(fl, lhsp, rhsp, thsp) {}
-    ASTGEN_MEMBERS_PostSub;
+    ASTGEN_MEMBERS_AstPostSub;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
                        const V3Number& ths) override {
         V3ERROR_NA;  // Need to modify lhs
@@ -3244,7 +3244,7 @@ class AstPreAdd final : public AstNodeTriop {
 public:
     AstPreAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
         : ASTGEN_SUPER_PreAdd(fl, lhsp, rhsp, thsp) {}
-    ASTGEN_MEMBERS_PreAdd;
+    ASTGEN_MEMBERS_AstPreAdd;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
                        const V3Number& ths) override {
         V3ERROR_NA;  // Need to modify lhs
@@ -3269,7 +3269,7 @@ class AstPreSub final : public AstNodeTriop {
 public:
     AstPreSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp)
         : ASTGEN_SUPER_PreSub(fl, lhsp, rhsp, thsp) {}
-    ASTGEN_MEMBERS_PreSub;
+    ASTGEN_MEMBERS_AstPreSub;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
                        const V3Number& ths) override {
         V3ERROR_NA;  // Need to modify lhs
@@ -3292,7 +3292,7 @@ public:
         : ASTGEN_SUPER_PutcN(fl, lhsp, rhsp, ths) {
         dtypeSetString();
     }
-    ASTGEN_MEMBERS_PutcN;
+    ASTGEN_MEMBERS_AstPutcN;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
                        const V3Number& ths) override {
         out.opPutcN(lhs, rhs, ths);
@@ -3332,7 +3332,7 @@ public:
         , m_declElWidth{1} {
         dtypeSetLogicSized(bitwidth, VSigning::UNSIGNED);
     }
-    ASTGEN_MEMBERS_Sel;
+    ASTGEN_MEMBERS_AstSel;
     void dump(std::ostream& str) const override;
     void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit,
                        const V3Number& width) override {
@@ -3373,7 +3373,7 @@ public:
         : ASTGEN_SUPER_SliceSel(fl, fromp, new AstConst(fl, declRange.lo()),
                                 new AstConst(fl, declRange.elements()))
         , m_declRange{declRange} {}
-    ASTGEN_MEMBERS_SliceSel;
+    ASTGEN_MEMBERS_AstSliceSel;
     void dump(std::ostream& str) const override;
     void numberOperate(V3Number& out, const V3Number& from, const V3Number& lo,
                        const V3Number& width) override {
@@ -3402,7 +3402,7 @@ public:
         : ASTGEN_SUPER_SubstrN(fl, lhsp, rhsp, ths) {
         dtypeSetString();
     }
-    ASTGEN_MEMBERS_SubstrN;
+    ASTGEN_MEMBERS_AstSubstrN;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
                        const V3Number& ths) override {
         out.opSubstrN(lhs, rhs, ths);
@@ -3428,7 +3428,7 @@ class AstCond final : public AstNodeCond {
 public:
     AstCond(FileLine* fl, AstNode* condp, AstNode* thenp, AstNode* elsep)
         : ASTGEN_SUPER_Cond(fl, condp, thenp, elsep) {}
-    ASTGEN_MEMBERS_Cond;
+    ASTGEN_MEMBERS_AstCond;
     AstNode* cloneType(AstNode* condp, AstNode* thenp, AstNode* elsep) override {
         return new AstCond(this->fileline(), condp, thenp, elsep);
     }
@@ -3440,7 +3440,7 @@ class AstCondBound final : public AstNodeCond {
 public:
     AstCondBound(FileLine* fl, AstNode* condp, AstNode* thenp, AstNode* elsep)
         : ASTGEN_SUPER_CondBound(fl, condp, thenp, elsep) {}
-    ASTGEN_MEMBERS_CondBound;
+    ASTGEN_MEMBERS_AstCondBound;
     AstNode* cloneType(AstNode* condp, AstNode* thenp, AstNode* elsep) override {
         return new AstCondBound(this->fileline(), condp, thenp, elsep);
     }
@@ -3460,7 +3460,7 @@ public:
         , m_fmt{fmt} {
         fmt == ATOREAL ? dtypeSetDouble() : dtypeSetSigned32();
     }
-    ASTGEN_MEMBERS_AtoN;
+    ASTGEN_MEMBERS_AstAtoN;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAtoN(lhs, m_fmt); }
     string name() const override {
         switch (m_fmt) {
@@ -3494,7 +3494,7 @@ public:
         : ASTGEN_SUPER_BitsToRealD(fl, lhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_BitsToRealD;
+    ASTGEN_MEMBERS_AstBitsToRealD;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opBitsToRealD(lhs); }
     string emitVerilog() override { return "%f$bitstoreal(%l)"; }
     string emitC() override { return "VL_CVT_D_Q(%li)"; }
@@ -3522,7 +3522,7 @@ public:
         dtypeFrom(typeFromp);
         m_size = width();
     }
-    ASTGEN_MEMBERS_CCast;
+    ASTGEN_MEMBERS_AstCCast;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); }
     string emitVerilog() override { return "%f$_CAST(%l)"; }
     string emitC() override { return "VL_CAST_%nq%lq(%nw,%lw, %P, %li)"; }
@@ -3542,7 +3542,7 @@ public:
         : ASTGEN_SUPER_CLog2(fl, lhsp) {
         dtypeSetSigned32();
     }
-    ASTGEN_MEMBERS_CLog2;
+    ASTGEN_MEMBERS_AstCLog2;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opCLog2(lhs); }
     string emitVerilog() override { return "%f$clog2(%l)"; }
     string emitC() override { return "VL_CLOG2_%lq(%lW, %P, %li)"; }
@@ -3556,7 +3556,7 @@ class AstCountOnes final : public AstNodeUniop {
 public:
     AstCountOnes(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_CountOnes(fl, lhsp) {}
-    ASTGEN_MEMBERS_CountOnes;
+    ASTGEN_MEMBERS_AstCountOnes;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opCountOnes(lhs); }
     string emitVerilog() override { return "%f$countones(%l)"; }
     string emitC() override { return "VL_COUNTONES_%lq(%lW, %P, %li)"; }
@@ -3572,7 +3572,7 @@ public:
         : ASTGEN_SUPER_CvtPackString(fl, lhsp) {
         dtypeSetString();
     }
-    ASTGEN_MEMBERS_CvtPackString;
+    ASTGEN_MEMBERS_AstCvtPackString;
     void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; }
     string emitVerilog() override { return "%f$_CAST(%l)"; }
     string emitC() override { return "VL_CVT_PACK_STR_N%lq(%lW, %li)"; }
@@ -3590,7 +3590,7 @@ public:
         : ASTGEN_SUPER_Extend(fl, lhsp) {
         dtypeSetLogicSized(width, VSigning::UNSIGNED);
     }
-    ASTGEN_MEMBERS_Extend;
+    ASTGEN_MEMBERS_AstExtend;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); }
     string emitVerilog() override { return "%l"; }
     string emitC() override { return "VL_EXTEND_%nq%lq(%nw,%lw, %P, %li)"; }
@@ -3611,7 +3611,7 @@ public:
         : ASTGEN_SUPER_ExtendS(fl, lhsp) {
         dtypeSetLogicSized(width, VSigning::UNSIGNED);
     }
-    ASTGEN_MEMBERS_ExtendS;
+    ASTGEN_MEMBERS_AstExtendS;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.opExtendS(lhs, lhsp()->widthMinV());
     }
@@ -3629,7 +3629,7 @@ class AstFEof final : public AstNodeUniop {
 public:
     AstFEof(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_FEof(fl, lhsp) {}
-    ASTGEN_MEMBERS_FEof;
+    ASTGEN_MEMBERS_AstFEof;
     void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; }
     string emitVerilog() override { return "%f$feof(%l)"; }
     string emitC() override { return "(%li ? feof(VL_CVT_I_FP(%li)) : true)"; }
@@ -3644,7 +3644,7 @@ class AstFGetC final : public AstNodeUniop {
 public:
     AstFGetC(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_FGetC(fl, lhsp) {}
-    ASTGEN_MEMBERS_FGetC;
+    ASTGEN_MEMBERS_AstFGetC;
     void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; }
     string emitVerilog() override { return "%f$fgetc(%l)"; }
     // Non-existent filehandle returns EOF
@@ -3663,7 +3663,7 @@ public:
         : ASTGEN_SUPER_ISToRD(fl, lhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_ISToRD;
+    ASTGEN_MEMBERS_AstISToRD;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opISToRD(lhs); }
     string emitVerilog() override { return "%f$itor($signed(%l))"; }
     string emitC() override { return "VL_ISTOR_D_%lq(%lw, %li)"; }
@@ -3680,7 +3680,7 @@ public:
         : ASTGEN_SUPER_IToRD(fl, lhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_IToRD;
+    ASTGEN_MEMBERS_AstIToRD;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opIToRD(lhs); }
     string emitVerilog() override { return "%f$itor(%l)"; }
     string emitC() override { return "VL_ITOR_D_%lq(%lw, %li)"; }
@@ -3696,7 +3696,7 @@ public:
         : ASTGEN_SUPER_IsUnbounded(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_IsUnbounded;
+    ASTGEN_MEMBERS_AstIsUnbounded;
     void numberOperate(V3Number& out, const V3Number&) override {
         // Any constant isn't unbounded
         out.setZero();
@@ -3714,7 +3714,7 @@ public:
         : ASTGEN_SUPER_IsUnknown(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_IsUnknown;
+    ASTGEN_MEMBERS_AstIsUnknown;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opIsUnknown(lhs); }
     string emitVerilog() override { return "%f$isunknown(%l)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -3729,7 +3729,7 @@ public:
         : ASTGEN_SUPER_LenN(fl, lhsp) {
         dtypeSetSigned32();
     }
-    ASTGEN_MEMBERS_LenN;
+    ASTGEN_MEMBERS_AstLenN;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opLenN(lhs); }
     string emitVerilog() override { return "%f(%l)"; }
     string emitC() override { return "VL_LEN_IN(%li)"; }
@@ -3743,7 +3743,7 @@ public:
         : ASTGEN_SUPER_LogNot(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_LogNot;
+    ASTGEN_MEMBERS_AstLogNot;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opLogNot(lhs); }
     string emitVerilog() override { return "%f(! %l)"; }
     string emitC() override { return "VL_LOGNOT_%nq%lq(%nw,%lw, %P, %li)"; }
@@ -3758,7 +3758,7 @@ public:
         : ASTGEN_SUPER_Negate(fl, lhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Negate;
+    ASTGEN_MEMBERS_AstNegate;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNegate(lhs); }
     string emitVerilog() override { return "%f(- %l)"; }
     string emitC() override { return "VL_NEGATE_%lq(%lW, %P, %li)"; }
@@ -3773,7 +3773,7 @@ public:
         : ASTGEN_SUPER_NegateD(fl, lhsp) {
         dtypeSetDouble();
     }
-    ASTGEN_MEMBERS_NegateD;
+    ASTGEN_MEMBERS_AstNegateD;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNegateD(lhs); }
     string emitVerilog() override { return "%f(- %l)"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -3790,7 +3790,7 @@ public:
         : ASTGEN_SUPER_Not(fl, lhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Not;
+    ASTGEN_MEMBERS_AstNot;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNot(lhs); }
     string emitVerilog() override { return "%f(~ %l)"; }
     string emitC() override { return "VL_NOT_%lq(%lW, %P, %li)"; }
@@ -3807,7 +3807,7 @@ public:
         : ASTGEN_SUPER_NullCheck(fl, lhsp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_NullCheck;
+    ASTGEN_MEMBERS_AstNullCheck;
     void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; }
     int instrCount() const override { return 1; }  // Rarely executes
     string emitVerilog() override { return "%l"; }
@@ -3825,7 +3825,7 @@ public:
         : ASTGEN_SUPER_OneHot(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_OneHot;
+    ASTGEN_MEMBERS_AstOneHot;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opOneHot(lhs); }
     string emitVerilog() override { return "%f$onehot(%l)"; }
     string emitC() override { return "VL_ONEHOT_%lq(%lW, %P, %li)"; }
@@ -3841,7 +3841,7 @@ public:
         : ASTGEN_SUPER_OneHot0(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_OneHot0;
+    ASTGEN_MEMBERS_AstOneHot0;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opOneHot0(lhs); }
     string emitVerilog() override { return "%f$onehot0(%l)"; }
     string emitC() override { return "VL_ONEHOT0_%lq(%lW, %P, %li)"; }
@@ -3857,7 +3857,7 @@ public:
         : ASTGEN_SUPER_RToIRoundS(fl, lhsp) {
         dtypeSetSigned32();
     }
-    ASTGEN_MEMBERS_RToIRoundS;
+    ASTGEN_MEMBERS_AstRToIRoundS;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRToIRoundS(lhs); }
     string emitVerilog() override { return "%f$rtoi_rounded(%l)"; }
     string emitC() override {
@@ -3875,7 +3875,7 @@ public:
         : ASTGEN_SUPER_RToIS(fl, lhsp) {
         dtypeSetSigned32();
     }
-    ASTGEN_MEMBERS_RToIS;
+    ASTGEN_MEMBERS_AstRToIS;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRToIS(lhs); }
     string emitVerilog() override { return "%f$rtoi(%l)"; }
     string emitC() override { return "VL_RTOI_I_D(%li)"; }
@@ -3890,7 +3890,7 @@ public:
         : ASTGEN_SUPER_RealToBits(fl, lhsp) {
         dtypeSetUInt64();
     }
-    ASTGEN_MEMBERS_RealToBits;
+    ASTGEN_MEMBERS_AstRealToBits;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRealToBits(lhs); }
     string emitVerilog() override { return "%f$realtobits(%l)"; }
     string emitC() override { return "VL_CVT_Q_D(%li)"; }
@@ -3905,7 +3905,7 @@ public:
         : ASTGEN_SUPER_RedAnd(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_RedAnd;
+    ASTGEN_MEMBERS_AstRedAnd;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedAnd(lhs); }
     string emitVerilog() override { return "%f(& %l)"; }
     string emitC() override { return "VL_REDAND_%nq%lq(%lw, %P, %li)"; }
@@ -3919,7 +3919,7 @@ public:
         : ASTGEN_SUPER_RedOr(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_RedOr;
+    ASTGEN_MEMBERS_AstRedOr;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedOr(lhs); }
     string emitVerilog() override { return "%f(| %l)"; }
     string emitC() override { return "VL_REDOR_%lq(%lW, %P, %li)"; }
@@ -3933,7 +3933,7 @@ public:
         : ASTGEN_SUPER_RedXor(fl, lhsp) {
         dtypeSetBit();
     }
-    ASTGEN_MEMBERS_RedXor;
+    ASTGEN_MEMBERS_AstRedXor;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedXor(lhs); }
     string emitVerilog() override { return "%f(^ %l)"; }
     string emitC() override { return "VL_REDXOR_%lq(%lW, %P, %li)"; }
@@ -3953,7 +3953,7 @@ public:
         UASSERT_OBJ(!v3Global.assertDTypesResolved(), this,
                     "not coded to create after dtypes resolved");
     }
-    ASTGEN_MEMBERS_Signed;
+    ASTGEN_MEMBERS_AstSigned;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.opAssign(lhs);
         out.isSigned(false);
@@ -3971,7 +3971,7 @@ class AstTimeImport final : public AstNodeUniop {
 public:
     AstTimeImport(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_TimeImport(fl, lhsp) {}
-    ASTGEN_MEMBERS_TimeImport;
+    ASTGEN_MEMBERS_AstTimeImport;
     void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; }
     string emitVerilog() override { return "%l"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
@@ -3989,7 +3989,7 @@ public:
         : ASTGEN_SUPER_ToLowerN(fl, lhsp) {
         dtypeSetString();
     }
-    ASTGEN_MEMBERS_ToLowerN;
+    ASTGEN_MEMBERS_AstToLowerN;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opToLowerN(lhs); }
     string emitVerilog() override { return "%l.tolower()"; }
     string emitC() override { return "VL_TOLOWER_NN(%li)"; }
@@ -4004,7 +4004,7 @@ public:
         : ASTGEN_SUPER_ToUpperN(fl, lhsp) {
         dtypeSetString();
     }
-    ASTGEN_MEMBERS_ToUpperN;
+    ASTGEN_MEMBERS_AstToUpperN;
     void numberOperate(V3Number& out, const V3Number& lhs) override { out.opToUpperN(lhs); }
     string emitVerilog() override { return "%l.toupper()"; }
     string emitC() override { return "VL_TOUPPER_NN(%li)"; }
@@ -4020,7 +4020,7 @@ public:
         UASSERT_OBJ(!v3Global.assertDTypesResolved(), this,
                     "not coded to create after dtypes resolved");
     }
-    ASTGEN_MEMBERS_Unsigned;
+    ASTGEN_MEMBERS_AstUnsigned;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.opAssign(lhs);
         out.isSigned(false);
@@ -4038,7 +4038,7 @@ class AstAcosD final : public AstNodeSystemUniop {
 public:
     AstAcosD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_AcosD(fl, lhsp) {}
-    ASTGEN_MEMBERS_AcosD;
+    ASTGEN_MEMBERS_AstAcosD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::acos(lhs.toDouble()));
     }
@@ -4049,7 +4049,7 @@ class AstAcoshD final : public AstNodeSystemUniop {
 public:
     AstAcoshD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_AcoshD(fl, lhsp) {}
-    ASTGEN_MEMBERS_AcoshD;
+    ASTGEN_MEMBERS_AstAcoshD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::acosh(lhs.toDouble()));
     }
@@ -4060,7 +4060,7 @@ class AstAsinD final : public AstNodeSystemUniop {
 public:
     AstAsinD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_AsinD(fl, lhsp) {}
-    ASTGEN_MEMBERS_AsinD;
+    ASTGEN_MEMBERS_AstAsinD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::asin(lhs.toDouble()));
     }
@@ -4071,7 +4071,7 @@ class AstAsinhD final : public AstNodeSystemUniop {
 public:
     AstAsinhD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_AsinhD(fl, lhsp) {}
-    ASTGEN_MEMBERS_AsinhD;
+    ASTGEN_MEMBERS_AstAsinhD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::asinh(lhs.toDouble()));
     }
@@ -4082,7 +4082,7 @@ class AstAtanD final : public AstNodeSystemUniop {
 public:
     AstAtanD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_AtanD(fl, lhsp) {}
-    ASTGEN_MEMBERS_AtanD;
+    ASTGEN_MEMBERS_AstAtanD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::atan(lhs.toDouble()));
     }
@@ -4093,7 +4093,7 @@ class AstAtanhD final : public AstNodeSystemUniop {
 public:
     AstAtanhD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_AtanhD(fl, lhsp) {}
-    ASTGEN_MEMBERS_AtanhD;
+    ASTGEN_MEMBERS_AstAtanhD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::atanh(lhs.toDouble()));
     }
@@ -4104,7 +4104,7 @@ class AstCeilD final : public AstNodeSystemUniop {
 public:
     AstCeilD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_CeilD(fl, lhsp) {}
-    ASTGEN_MEMBERS_CeilD;
+    ASTGEN_MEMBERS_AstCeilD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::ceil(lhs.toDouble()));
     }
@@ -4115,7 +4115,7 @@ class AstCosD final : public AstNodeSystemUniop {
 public:
     AstCosD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_CosD(fl, lhsp) {}
-    ASTGEN_MEMBERS_CosD;
+    ASTGEN_MEMBERS_AstCosD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::cos(lhs.toDouble()));
     }
@@ -4126,7 +4126,7 @@ class AstCoshD final : public AstNodeSystemUniop {
 public:
     AstCoshD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_CoshD(fl, lhsp) {}
-    ASTGEN_MEMBERS_CoshD;
+    ASTGEN_MEMBERS_AstCoshD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::cosh(lhs.toDouble()));
     }
@@ -4137,7 +4137,7 @@ class AstExpD final : public AstNodeSystemUniop {
 public:
     AstExpD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_ExpD(fl, lhsp) {}
-    ASTGEN_MEMBERS_ExpD;
+    ASTGEN_MEMBERS_AstExpD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::exp(lhs.toDouble()));
     }
@@ -4148,7 +4148,7 @@ class AstFloorD final : public AstNodeSystemUniop {
 public:
     AstFloorD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_FloorD(fl, lhsp) {}
-    ASTGEN_MEMBERS_FloorD;
+    ASTGEN_MEMBERS_AstFloorD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::floor(lhs.toDouble()));
     }
@@ -4159,7 +4159,7 @@ class AstLog10D final : public AstNodeSystemUniop {
 public:
     AstLog10D(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_Log10D(fl, lhsp) {}
-    ASTGEN_MEMBERS_Log10D;
+    ASTGEN_MEMBERS_AstLog10D;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::log10(lhs.toDouble()));
     }
@@ -4170,7 +4170,7 @@ class AstLogD final : public AstNodeSystemUniop {
 public:
     AstLogD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_LogD(fl, lhsp) {}
-    ASTGEN_MEMBERS_LogD;
+    ASTGEN_MEMBERS_AstLogD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::log(lhs.toDouble()));
     }
@@ -4181,7 +4181,7 @@ class AstSinD final : public AstNodeSystemUniop {
 public:
     AstSinD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_SinD(fl, lhsp) {}
-    ASTGEN_MEMBERS_SinD;
+    ASTGEN_MEMBERS_AstSinD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::sin(lhs.toDouble()));
     }
@@ -4192,7 +4192,7 @@ class AstSinhD final : public AstNodeSystemUniop {
 public:
     AstSinhD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_SinhD(fl, lhsp) {}
-    ASTGEN_MEMBERS_SinhD;
+    ASTGEN_MEMBERS_AstSinhD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::sinh(lhs.toDouble()));
     }
@@ -4203,7 +4203,7 @@ class AstSqrtD final : public AstNodeSystemUniop {
 public:
     AstSqrtD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_SqrtD(fl, lhsp) {}
-    ASTGEN_MEMBERS_SqrtD;
+    ASTGEN_MEMBERS_AstSqrtD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::sqrt(lhs.toDouble()));
     }
@@ -4214,7 +4214,7 @@ class AstTanD final : public AstNodeSystemUniop {
 public:
     AstTanD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_TanD(fl, lhsp) {}
-    ASTGEN_MEMBERS_TanD;
+    ASTGEN_MEMBERS_AstTanD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::tan(lhs.toDouble()));
     }
@@ -4225,7 +4225,7 @@ class AstTanhD final : public AstNodeSystemUniop {
 public:
     AstTanhD(FileLine* fl, AstNode* lhsp)
         : ASTGEN_SUPER_TanhD(fl, lhsp) {}
-    ASTGEN_MEMBERS_TanhD;
+    ASTGEN_MEMBERS_AstTanhD;
     void numberOperate(V3Number& out, const V3Number& lhs) override {
         out.setDouble(std::tanh(lhs.toDouble()));
     }
@@ -4244,7 +4244,7 @@ public:
     inline AstVarRef(FileLine* fl, AstVar* varp, const VAccess& access);
     // This form only allowed post-link (see above)
     inline AstVarRef(FileLine* fl, AstVarScope* varscp, const VAccess& access);
-    ASTGEN_MEMBERS_VarRef;
+    ASTGEN_MEMBERS_AstVarRef;
     void dump(std::ostream& str) const override;
     bool same(const AstNode* samep) const override;
     inline bool same(const AstVarRef* samep) const;
@@ -4267,7 +4267,7 @@ public:
         : ASTGEN_SUPER_VarXRef(fl, name, nullptr, access)
         , m_dotted{dotted} {}
     inline AstVarXRef(FileLine* fl, AstVar* varp, const string& dotted, const VAccess& access);
-    ASTGEN_MEMBERS_VarXRef;
+    ASTGEN_MEMBERS_AstVarXRef;
     void dump(std::ostream& str) const override;
     string dotted() const { return m_dotted; }
     void dotted(const string& dotted) { m_dotted = dotted; }
diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h
index dcf3afbb3..3ef73b94a 100644
--- a/src/V3AstNodeOther.h
+++ b/src/V3AstNodeOther.h
@@ -46,7 +46,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeBlock;
+    ASTGEN_MEMBERS_AstNodeBlock;
     void dump(std::ostream& str) const override;
     string name() const override { return m_name; }  // * = Block name
     void name(const string& name) override { m_name = name; }
@@ -116,7 +116,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeFTask;
+    ASTGEN_MEMBERS_AstNodeFTask;
     void dump(std::ostream& str = std::cout) const override;
     string name() const override { return m_name; }  // * = Var name
     bool maybePointedTo() const override { return true; }
@@ -184,7 +184,7 @@ public:
     AstNodeFile(VNType t, FileLine* fl, const string& name)
         : AstNode{t, fl}
         , m_name{name} {}
-    ASTGEN_MEMBERS_NodeFile;
+    ASTGEN_MEMBERS_AstNodeFile;
     void dump(std::ostream& str) const override;
     string name() const override { return m_name; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -228,7 +228,7 @@ protected:
         , m_recursiveClone{false} {}
 
 public:
-    ASTGEN_MEMBERS_NodeModule;
+    ASTGEN_MEMBERS_AstNodeModule;
     void dump(std::ostream& str) const override;
     bool maybePointedTo() const override { return true; }
     string name() const override { return m_name; }
@@ -279,7 +279,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodePreSel;
+    ASTGEN_MEMBERS_AstNodePreSel;
     // METHODS
     bool same(const AstNode*) const override { return true; }
 };
@@ -294,7 +294,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeProcedure;
+    ASTGEN_MEMBERS_AstNodeProcedure;
     // METHODS
     void dump(std::ostream& str) const override;
     bool isJustOneBodyStmt() const { return stmtsp() && !stmtsp()->nextp(); }
@@ -308,7 +308,7 @@ protected:
         : AstNode{t, fl} {}
 
 public:
-    ASTGEN_MEMBERS_NodeRange;
+    ASTGEN_MEMBERS_AstNodeRange;
     void dump(std::ostream& str) const override;
 };
 class AstNodeStmt VL_NOT_FINAL : public AstNode {
@@ -320,7 +320,7 @@ protected:
         , m_statement{statement} {}
 
 public:
-    ASTGEN_MEMBERS_NodeStmt;
+    ASTGEN_MEMBERS_AstNodeStmt;
     // METHODS
     bool isStatement() const { return m_statement; }  // Really a statement
     void statement(bool flag) { m_statement = flag; }
@@ -346,7 +346,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeAssign;
+    ASTGEN_MEMBERS_AstNodeAssign;
     // Clone single node, just get same type back.
     virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) = 0;
     bool hasDType() const override { return true; }
@@ -373,7 +373,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeCCall;
+    ASTGEN_MEMBERS_AstNodeCCall;
     void dump(std::ostream& str = std::cout) const override;
     void cloneRelink() override;
     const char* broken() const override;
@@ -403,7 +403,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeCase;
+    ASTGEN_MEMBERS_AstNodeCase;
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
 };
 class AstNodeCoverOrAssert VL_NOT_FINAL : public AstNodeStmt {
@@ -424,7 +424,7 @@ public:
         this->propp(propp);
         this->addPasssp(passsp);
     }
-    ASTGEN_MEMBERS_NodeCoverOrAssert;
+    ASTGEN_MEMBERS_AstNodeCoverOrAssert;
     string name() const override { return m_name; }  // * = Var name
     bool same(const AstNode* samep) const override { return samep->name() == name(); }
     void name(const string& name) override { m_name = name; }
@@ -459,7 +459,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeFTaskRef;
+    ASTGEN_MEMBERS_AstNodeFTaskRef;
     const char* broken() const override;
     void cloneRelink() override;
     void dump(std::ostream& str = std::cout) const override;
@@ -493,7 +493,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeFor;
+    ASTGEN_MEMBERS_AstNodeFor;
     bool isGateOptimizable() const override { return false; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -515,7 +515,7 @@ protected:
     }
 
 public:
-    ASTGEN_MEMBERS_NodeIf;
+    ASTGEN_MEMBERS_AstNodeIf;
     bool isGateOptimizable() const override { return false; }
     bool isGateDedupable() const override { return true; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
@@ -545,7 +545,7 @@ public:
         this->lsbp(lsbp);
         this->msbp(msbp);
     }
-    ASTGEN_MEMBERS_NodeReadWriteMem;
+    ASTGEN_MEMBERS_AstNodeReadWriteMem;
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
     bool isPure() const override { return false; }
@@ -568,7 +568,7 @@ protected:
         , m_text{text} {}
 
 public:
-    ASTGEN_MEMBERS_NodeText;
+    ASTGEN_MEMBERS_AstNodeText;
     void dump(std::ostream& str = std::cout) const override;
     bool same(const AstNode* samep) const override {
         const AstNodeText* asamep = static_cast<const AstNodeText*>(samep);
@@ -584,7 +584,7 @@ public:
     AstNodeSimpleText(VNType t, FileLine* fl, const string& textp, bool tracking = false)
         : AstNodeText(t, fl, textp)
         , m_tracking(tracking) {}
-    ASTGEN_MEMBERS_NodeSimpleText;
+    ASTGEN_MEMBERS_AstNodeSimpleText;
     void tracking(bool flag) { m_tracking = flag; }
     bool tracking() const { return m_tracking; }
 };
@@ -608,7 +608,7 @@ public:
         , m_sensesp{sensesp} {
         UASSERT(sensesp, "Sensesp required arg");
     }
-    ASTGEN_MEMBERS_Active;
+    ASTGEN_MEMBERS_AstActive;
     void dump(std::ostream& str = std::cout) const override;
     string name() const override { return m_name; }
     const char* broken() const override;
@@ -630,7 +630,7 @@ public:
         , m_name{name} {
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_Arg;
+    ASTGEN_MEMBERS_AstArg;
     string name() const override { return m_name; }  // * = Pin name, ""=go by number
     void name(const string& name) override { m_name = name; }
     bool emptyConnectNoNext() const { return !exprp() && name() == "" && !nextp(); }
@@ -647,7 +647,7 @@ public:
         this->dimp(dimp);
         m_attrType = attrtype;
     }
-    ASTGEN_MEMBERS_AttrOf;
+    ASTGEN_MEMBERS_AstAttrOf;
     VAttrType attrType() const { return m_attrType; }
     void dump(std::ostream& str = std::cout) const override;
 };
@@ -664,7 +664,7 @@ public:
         UASSERT_OBJ(VN_IS(cellsp, Cell), cellsp, "Only instances allowed to be bound");
         this->addCellsp(cellsp);
     }
-    ASTGEN_MEMBERS_Bind;
+    ASTGEN_MEMBERS_AstBind;
     // ACCESSORS
     string name() const override { return m_name; }  // * = Bind Target name
     void name(const string& name) override { m_name = name; }
@@ -735,7 +735,7 @@ public:
         m_dpiImportWrapper = false;
         m_dpiTraceInit = false;
     }
-    ASTGEN_MEMBERS_CFunc;
+    ASTGEN_MEMBERS_AstCFunc;
     string name() const override { return m_name; }
     const char* broken() const override;
     void cloneRelink() override;
@@ -829,7 +829,7 @@ public:
         : ASTGEN_SUPER_CUse(fl)
         , m_useType{useType}
         , m_name{name} {}
-    ASTGEN_MEMBERS_CUse;
+    ASTGEN_MEMBERS_AstCUse;
     void dump(std::ostream& str = std::cout) const override;
     string name() const override { return m_name; }
     VUseType useType() const { return m_useType; }
@@ -844,7 +844,7 @@ public:
         this->addCondsp(condsp);
         this->addStmtsp(stmtsp);
     }
-    ASTGEN_MEMBERS_CaseItem;
+    ASTGEN_MEMBERS_AstCaseItem;
     int instrCount() const override { return widthInstrs() + INSTR_COUNT_BRANCH; }
     bool isDefault() const { return condsp() == nullptr; }
     bool isFirstInMyListOfStatements(AstNode* n) const override { return n == stmtsp(); }
@@ -865,7 +865,7 @@ public:
         this->fromp(fromp);
         dtypeFrom(dtp);
     }
-    ASTGEN_MEMBERS_Cast;
+    ASTGEN_MEMBERS_AstCast;
     bool hasDType() const override { return true; }
     virtual string emitVerilog() { return "((%d)'(%l))"; }
     virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); }
@@ -884,7 +884,7 @@ public:
         this->lhsp(lhsp);
         this->dtp(dtp);
     }
-    ASTGEN_MEMBERS_CastParse;
+    ASTGEN_MEMBERS_AstCastParse;
     virtual string emitVerilog() { return "((%d)'(%l))"; }
     virtual string emitC() { V3ERROR_NA_RETURN(""); }
     virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); }
@@ -901,7 +901,7 @@ public:
         this->lhsp(lhsp);
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_CastSize;
+    ASTGEN_MEMBERS_AstCastSize;
     // No hasDType because widthing removes this node before the hasDType check
     virtual string emitVerilog() { return "((%r)'(%l))"; }
     virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); }
@@ -937,7 +937,7 @@ public:
         this->addParamsp(paramsp);
         this->rangep(rangep);
     }
-    ASTGEN_MEMBERS_Cell;
+    ASTGEN_MEMBERS_AstCell;
     // No cloneRelink, we presume cloneee's want the same module linkages
     void dump(std::ostream& str) const override;
     const char* broken() const override;
@@ -969,7 +969,7 @@ public:
         , m_name{name} {
         this->addSelp(selp);
     }
-    ASTGEN_MEMBERS_CellArrayRef;
+    ASTGEN_MEMBERS_AstCellArrayRef;
     // ACCESSORS
     string name() const override { return m_name; }  // * = Array name
 };
@@ -992,7 +992,7 @@ public:
         , m_name{name}
         , m_origModName{origModName}
         , m_timeunit{timeunit} {}
-    ASTGEN_MEMBERS_CellInline;
+    ASTGEN_MEMBERS_AstCellInline;
     void dump(std::ostream& str) const override;
     const char* broken() const override;
     // ACCESSORS
@@ -1017,7 +1017,7 @@ public:
         this->cellp(cellp);
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_CellRef;
+    ASTGEN_MEMBERS_AstCellRef;
     // ACCESSORS
     string name() const override { return m_name; }  // * = Array name
 };
@@ -1031,7 +1031,7 @@ public:
         : ASTGEN_SUPER_ClassExtends(fl) {
         this->classOrPkgsp(classOrPkgsp);  // Only for parser
     }
-    ASTGEN_MEMBERS_ClassExtends;
+    ASTGEN_MEMBERS_AstClassExtends;
     bool hasDType() const override { return true; }
     string verilogKwd() const override { return "extends"; }
     AstClass* classp() const;  // Class being extended (after link)
@@ -1050,7 +1050,7 @@ public:
         , m_classOrPackageNodep{classOrPackageNodep} {
         this->addParamsp(paramsp);
     }
-    ASTGEN_MEMBERS_ClassOrPackageRef;
+    ASTGEN_MEMBERS_AstClassOrPackageRef;
     // METHODS
     const char* broken() const override {
         BROKEN_RTN(m_classOrPackageNodep && !m_classOrPackageNodep->brokeExists());
@@ -1084,7 +1084,7 @@ public:
         this->addSensesp(sensesp);
         this->addBodysp(bodysp);
     }
-    ASTGEN_MEMBERS_Clocking;
+    ASTGEN_MEMBERS_AstClocking;
 };
 class AstConstPool final : public AstNode {
     // Container for const static data
@@ -1098,7 +1098,7 @@ class AstConstPool final : public AstNode {
 
 public:
     explicit AstConstPool(FileLine* fl);
-    ASTGEN_MEMBERS_ConstPool;
+    ASTGEN_MEMBERS_AstConstPool;
     bool maybePointedTo() const override { return true; }
     const char* broken() const override;
     void cloneRelink() override { V3ERROR_NA; }
@@ -1131,7 +1131,7 @@ public:
         this->rhsp(rhsp);
     }
     string name() const override { return m_name; }  // * = Scope name
-    ASTGEN_MEMBERS_DefParam;
+    ASTGEN_MEMBERS_AstDefParam;
     bool same(const AstNode*) const override { return true; }
     string path() const { return m_path; }
 };
@@ -1148,7 +1148,7 @@ public:
         this->lhsp(lhsp);
         this->rhsp(rhsp);
     }
-    ASTGEN_MEMBERS_Dot;
+    ASTGEN_MEMBERS_AstDot;
     // For parser, make only if non-null package
     static AstNode* newIfPkg(FileLine* fl, AstNode* packageOrClassp, AstNode* rhsp) {
         if (!packageOrClassp) return rhsp;
@@ -1169,7 +1169,7 @@ public:
         : ASTGEN_SUPER_DpiExport(fl)
         , m_name{vname}
         , m_cname{cname} {}
-    ASTGEN_MEMBERS_DpiExport;
+    ASTGEN_MEMBERS_AstDpiExport;
     string name() const override { return m_name; }
     void name(const string& name) override { m_name = name; }
     string cname() const { return m_cname; }
@@ -1183,7 +1183,7 @@ private:
 
 public:
     inline AstElabDisplay(FileLine* fl, VDisplayType dispType, AstNode* exprsp);
-    ASTGEN_MEMBERS_ElabDisplay;
+    ASTGEN_MEMBERS_AstElabDisplay;
     const char* broken() const override {
         BROKEN_RTN(!fmtp());
         return nullptr;
@@ -1206,7 +1206,7 @@ class AstEmpty final : public AstNode {
 public:
     explicit AstEmpty(FileLine* fl)
         : ASTGEN_SUPER_Empty(fl) {}
-    ASTGEN_MEMBERS_Empty;
+    ASTGEN_MEMBERS_AstEmpty;
     bool same(const AstNode* /*samep*/) const override { return true; }
 };
 class AstExecGraph final : public AstNode {
@@ -1225,7 +1225,7 @@ class AstExecGraph final : public AstNode {
 
 public:
     explicit AstExecGraph(FileLine* fl, const string& name);
-    ASTGEN_MEMBERS_ExecGraph;
+    ASTGEN_MEMBERS_AstExecGraph;
     ~AstExecGraph() override;
     const char* broken() const override {
         BROKEN_RTN(!m_depGraphp);
@@ -1244,7 +1244,7 @@ public:
         : ASTGEN_SUPER_Implicit(fl) {
         this->addExprsp(exprsp);
     }
-    ASTGEN_MEMBERS_Implicit;
+    ASTGEN_MEMBERS_AstImplicit;
 };
 class AstInitArray final : public AstNode {
     // Set a var to a map of values
@@ -1266,7 +1266,7 @@ public:
         dtypep(newDTypep);
         this->defaultp(defaultp);
     }
-    ASTGEN_MEMBERS_InitArray;
+    ASTGEN_MEMBERS_AstInitArray;
     void dump(std::ostream& str) const override;
     const char* broken() const override;
     void cloneRelink() override;
@@ -1293,7 +1293,7 @@ public:
         : ASTGEN_SUPER_InitItem(fl) {
         this->valuep(valuep);
     }
-    ASTGEN_MEMBERS_InitItem;
+    ASTGEN_MEMBERS_AstInitItem;
     bool maybePointedTo() const override { return true; }
     bool hasDType() const override { return false; }  // See valuep()'s dtype instead
 };
@@ -1306,7 +1306,7 @@ public:
         : ASTGEN_SUPER_IntfRef(fl)
         , m_name{name} {}
     string name() const override { return m_name; }
-    ASTGEN_MEMBERS_IntfRef;
+    ASTGEN_MEMBERS_AstIntfRef;
 };
 class AstMTaskBody final : public AstNode {
     // Hold statements for each MTask
@@ -1316,7 +1316,7 @@ class AstMTaskBody final : public AstNode {
 public:
     explicit AstMTaskBody(FileLine* fl)
         : ASTGEN_SUPER_MTaskBody(fl) {}
-    ASTGEN_MEMBERS_MTaskBody;
+    ASTGEN_MEMBERS_AstMTaskBody;
     const char* broken() const override {
         BROKEN_RTN(!m_execMTaskp);
         return nullptr;
@@ -1344,7 +1344,7 @@ public:
     }
     string name() const override { return m_name; }
     bool maybePointedTo() const override { return true; }
-    ASTGEN_MEMBERS_Modport;
+    ASTGEN_MEMBERS_AstModport;
 };
 class AstModportFTaskRef final : public AstNode {
     // An import/export referenced under a modport
@@ -1360,7 +1360,7 @@ public:
         : ASTGEN_SUPER_ModportFTaskRef(fl)
         , m_name{name}
         , m_export{isExport} {}
-    ASTGEN_MEMBERS_ModportFTaskRef;
+    ASTGEN_MEMBERS_AstModportFTaskRef;
     const char* broken() const override;
     void cloneRelink() override;
     void dump(std::ostream& str) const override;
@@ -1383,7 +1383,7 @@ public:
         : ASTGEN_SUPER_ModportVarRef(fl)
         , m_name{name}
         , m_direction{direction} {}
-    ASTGEN_MEMBERS_ModportVarRef;
+    ASTGEN_MEMBERS_AstModportVarRef;
     const char* broken() const override;
     void cloneRelink() override;
     void dump(std::ostream& str) const override;
@@ -1417,7 +1417,7 @@ class AstNetlist final : public AstNode {
     uint32_t m_nextFreeMTaskProfilingID = 0;  // Next unique ID to use for PGO
 public:
     AstNetlist();
-    ASTGEN_MEMBERS_Netlist;
+    ASTGEN_MEMBERS_AstNetlist;
     const char* broken() const override;
     void cloneRelink() override { V3ERROR_NA; }
     string name() const override { return "$root"; }
@@ -1463,7 +1463,7 @@ public:
         : ASTGEN_SUPER_PackageExport(fl)
         , m_name{name}
         , m_packagep{packagep} {}
-    ASTGEN_MEMBERS_PackageExport;
+    ASTGEN_MEMBERS_AstPackageExport;
     const char* broken() const override;
     void cloneRelink() override;
     void dump(std::ostream& str) const override;
@@ -1477,7 +1477,7 @@ public:
     // cppcheck-suppress noExplicitConstructor
     AstPackageExportStarStar(FileLine* fl)
         : ASTGEN_SUPER_PackageExportStarStar(fl) {}
-    ASTGEN_MEMBERS_PackageExportStarStar;
+    ASTGEN_MEMBERS_AstPackageExportStarStar;
 };
 class AstPackageImport final : public AstNode {
 private:
@@ -1489,7 +1489,7 @@ public:
         : ASTGEN_SUPER_PackageImport(fl)
         , m_name{name}
         , m_packagep{packagep} {}
-    ASTGEN_MEMBERS_PackageImport;
+    ASTGEN_MEMBERS_AstPackageImport;
     const char* broken() const override;
     void cloneRelink() override;
     void dump(std::ostream& str) const override;
@@ -1517,7 +1517,7 @@ public:
         this->lhsp(lhsp);
         this->ftaskrefp(ftaskrefp);
     }
-    ASTGEN_MEMBERS_ParseRef;
+    ASTGEN_MEMBERS_AstParseRef;
     void dump(std::ostream& str) const override;
     string name() const override { return m_name; }  // * = Var name
     bool same(const AstNode* samep) const override {
@@ -1546,7 +1546,7 @@ public:
         this->exprp(exprp);
     }
     inline AstPin(FileLine* fl, int pinNum, AstVarRef* varname, AstNode* exprp);
-    ASTGEN_MEMBERS_Pin;
+    ASTGEN_MEMBERS_AstPin;
     void dump(std::ostream& str) const override;
     const char* broken() const override;
     string name() const override { return m_name; }  // * = Pin name, ""=go by number
@@ -1574,7 +1574,7 @@ public:
         : ASTGEN_SUPER_Port(fl)
         , m_pinNum{pinnum}
         , m_name{name} {}
-    ASTGEN_MEMBERS_Port;
+    ASTGEN_MEMBERS_AstPort;
     string name() const override { return m_name; }  // * = Port name
     int pinNum() const { return m_pinNum; }  // * = Pin number, for order based instantiation
 };
@@ -1586,7 +1586,7 @@ public:
     AstPragma(FileLine* fl, VPragmaType pragType)
         : ASTGEN_SUPER_Pragma(fl)
         , m_pragType{pragType} {}
-    ASTGEN_MEMBERS_Pragma;
+    ASTGEN_MEMBERS_AstPragma;
     VPragmaType pragType() const { return m_pragType; }  // *=type of the pragma
     bool isPredictOptimizable() const override { return false; }
     bool same(const AstNode* samep) const override {
@@ -1607,7 +1607,7 @@ public:
         this->disablep(disablep);
         this->propp(propp);
     }
-    ASTGEN_MEMBERS_PropClocked;
+    ASTGEN_MEMBERS_AstPropClocked;
     bool hasDType() const override {
         return true;
     }  // Used under Cover, which expects a bool child
@@ -1623,7 +1623,7 @@ public:
         , m_direction{direction} {
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_Pull;
+    ASTGEN_MEMBERS_AstPull;
     bool same(const AstNode* samep) const override {
         return direction() == static_cast<const AstPull*>(samep)->direction();
     }
@@ -1661,7 +1661,7 @@ public:
         dtypeSetString();
         addExprsp(exprsp);
     }
-    ASTGEN_MEMBERS_SFormatF;
+    ASTGEN_MEMBERS_AstSFormatF;
     string name() const override { return m_text; }
     int instrCount() const override { return INSTR_COUNT_PLI; }
     bool hasDType() const override { return true; }
@@ -1701,7 +1701,7 @@ public:
         , m_aboveScopep{aboveScopep}
         , m_aboveCellp{aboveCellp}
         , m_modp{modp} {}
-    ASTGEN_MEMBERS_Scope;
+    ASTGEN_MEMBERS_AstScope;
     void cloneRelink() override;
     const char* broken() const override;
     bool maybePointedTo() const override { return true; }
@@ -1731,7 +1731,7 @@ public:
         this->fromp(fromp);
         this->addElementsp(elementsp);
     }
-    ASTGEN_MEMBERS_SelLoopVars;
+    ASTGEN_MEMBERS_AstSelLoopVars;
     bool same(const AstNode* /*samep*/) const override { return true; }
     bool maybePointedTo() const override { return false; }
 };
@@ -1769,7 +1769,7 @@ public:
     AstSenItem(FileLine* fl, Never)
         : ASTGEN_SUPER_SenItem(fl)
         , m_edgeType{VEdgeType::ET_NEVER} {}
-    ASTGEN_MEMBERS_SenItem;
+    ASTGEN_MEMBERS_AstSenItem;
     void dump(std::ostream& str) const override;
     bool same(const AstNode* samep) const override {
         return edgeType() == static_cast<const AstSenItem*>(samep)->edgeType();
@@ -1799,7 +1799,7 @@ public:
         : ASTGEN_SUPER_SenTree(fl) {
         this->addSensesp(sensesp);
     }
-    ASTGEN_MEMBERS_SenTree;
+    ASTGEN_MEMBERS_AstSenTree;
     void dump(std::ostream& str) const override;
     bool maybePointedTo() const override { return true; }
     bool isMulti() const { return m_multi; }
@@ -1817,7 +1817,7 @@ public:
     // Dummy node used within V3Split; never exists outside of V3Split.
     explicit AstSplitPlaceholder(FileLine* fl)
         : ASTGEN_SUPER_SplitPlaceholder(fl) {}
-    ASTGEN_MEMBERS_SplitPlaceholder;
+    ASTGEN_MEMBERS_AstSplitPlaceholder;
 };
 class AstStrengthSpec final : public AstNode {
 private:
@@ -1830,7 +1830,7 @@ public:
         , m_s0{s0}
         , m_s1{s1} {}
 
-    ASTGEN_MEMBERS_StrengthSpec;
+    ASTGEN_MEMBERS_AstStrengthSpec;
     VStrength strength0() { return m_s0; }
     VStrength strength1() { return m_s1; }
     void dump(std::ostream& str) const override;
@@ -1850,7 +1850,7 @@ class AstTopScope final : public AstNode {
     }
 
 public:
-    ASTGEN_MEMBERS_TopScope;
+    ASTGEN_MEMBERS_AstTopScope;
     bool maybePointedTo() const override { return true; }
 };
 class AstTypeTable final : public AstNode {
@@ -1866,7 +1866,7 @@ class AstTypeTable final : public AstNode {
 
 public:
     explicit AstTypeTable(FileLine* fl);
-    ASTGEN_MEMBERS_TypeTable;
+    ASTGEN_MEMBERS_AstTypeTable;
     bool maybePointedTo() const override { return true; }
     const char* broken() const override {
         BROKEN_RTN(m_emptyQueuep && !m_emptyQueuep->brokeExists());
@@ -1904,7 +1904,7 @@ public:
         addAttrsp(attrsp);
         dtypep(nullptr);  // V3Width will resolve
     }
-    ASTGEN_MEMBERS_Typedef;
+    ASTGEN_MEMBERS_AstTypedef;
     void dump(std::ostream& str) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
     virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); }
@@ -1927,7 +1927,7 @@ public:
     AstTypedefFwd(FileLine* fl, const string& name)
         : ASTGEN_SUPER_TypedefFwd(fl)
         , m_name{name} {}
-    ASTGEN_MEMBERS_TypedefFwd;
+    ASTGEN_MEMBERS_AstTypedefFwd;
     // METHODS
     string name() const override { return m_name; }
     bool maybePointedTo() const override { return true; }
@@ -1939,7 +1939,7 @@ public:
         : ASTGEN_SUPER_UdpTable(fl) {
         this->addLinesp(linesp);
     }
-    ASTGEN_MEMBERS_UdpTable;
+    ASTGEN_MEMBERS_AstUdpTable;
 };
 class AstUdpTableLine final : public AstNode {
     string m_text;
@@ -1948,7 +1948,7 @@ public:
     AstUdpTableLine(FileLine* fl, const string& text)
         : ASTGEN_SUPER_UdpTableLine(fl)
         , m_text{text} {}
-    ASTGEN_MEMBERS_UdpTableLine;
+    ASTGEN_MEMBERS_AstUdpTableLine;
     string name() const override { return m_text; }
     string text() const { return m_text; }
 };
@@ -1965,7 +1965,7 @@ public:
         this->refp(refp);
         this->cellrefp(cellrefp);
     }
-    ASTGEN_MEMBERS_UnlinkedRef;
+    ASTGEN_MEMBERS_AstUnlinkedRef;
 };
 class AstVar final : public AstNode {
     // A variable (in/out/wire/reg/param) inside a module
@@ -2130,7 +2130,7 @@ public:
         dtypeFrom(examplep);
         m_declKwd = examplep->declKwd();
     }
-    ASTGEN_MEMBERS_Var;
+    ASTGEN_MEMBERS_AstVar;
     void dump(std::ostream& str) const override;
     string name() const override { return m_name; }  // * = Var name
     bool hasDType() const override { return true; }
@@ -2354,7 +2354,7 @@ public:
         m_trace = true;
         dtypeFrom(varp);
     }
-    ASTGEN_MEMBERS_VarScope;
+    ASTGEN_MEMBERS_AstVarScope;
     void cloneRelink() override {
         if (m_varp && m_varp->clonep()) {
             m_varp = m_varp->clonep();
@@ -2393,7 +2393,7 @@ public:
         : ASTGEN_SUPER_Begin(fl, name, stmtsp)
         , m_generate{generate}
         , m_implied{implied} {}
-    ASTGEN_MEMBERS_Begin;
+    ASTGEN_MEMBERS_AstBegin;
     void dump(std::ostream& str) const override;
     void generate(bool flag) { m_generate = flag; }
     bool generate() const { return m_generate; }
@@ -2409,7 +2409,7 @@ public:
     // Node that puts name into the output stream
     AstFork(FileLine* fl, const string& name, AstNode* stmtsp)
         : ASTGEN_SUPER_Fork(fl, name, stmtsp) {}
-    ASTGEN_MEMBERS_Fork;
+    ASTGEN_MEMBERS_AstFork;
     bool isTimingControl() const override { return !joinType().joinNone(); }
     void dump(std::ostream& str) const override;
     VJoinType joinType() const { return m_joinType; }
@@ -2424,7 +2424,7 @@ public:
         : ASTGEN_SUPER_Func(fl, name, stmtp) {
         this->fvarp(fvarp);
     }
-    ASTGEN_MEMBERS_Func;
+    ASTGEN_MEMBERS_AstFunc;
     bool hasDType() const override { return true; }
 };
 class AstTask final : public AstNodeFTask {
@@ -2432,7 +2432,7 @@ class AstTask final : public AstNodeFTask {
 public:
     AstTask(FileLine* fl, const string& name, AstNode* stmtp)
         : ASTGEN_SUPER_Task(fl, name, stmtp) {}
-    ASTGEN_MEMBERS_Task;
+    ASTGEN_MEMBERS_AstTask;
 };
 
 // === AstNodeFile ===
@@ -2449,7 +2449,7 @@ public:
         , m_slow{false}
         , m_source{false}
         , m_support{false} {}
-    ASTGEN_MEMBERS_CFile;
+    ASTGEN_MEMBERS_AstCFile;
     void dump(std::ostream& str = std::cout) const override;
     bool slow() const { return m_slow; }
     void slow(bool flag) { m_slow = flag; }
@@ -2464,7 +2464,7 @@ class AstVFile final : public AstNodeFile {
 public:
     AstVFile(FileLine* fl, const string& name)
         : ASTGEN_SUPER_VFile(fl, name) {}
-    ASTGEN_MEMBERS_VFile;
+    ASTGEN_MEMBERS_AstVFile;
     void dump(std::ostream& str = std::cout) const override;
 };
 
@@ -2483,7 +2483,7 @@ class AstClass final : public AstNodeModule {
 public:
     AstClass(FileLine* fl, const string& name)
         : ASTGEN_SUPER_Class(fl, name) {}
-    ASTGEN_MEMBERS_Class;
+    ASTGEN_MEMBERS_AstClass;
     string verilogKwd() const override { return "class"; }
     bool maybePointedTo() const override { return true; }
     void dump(std::ostream& str) const override;
@@ -2518,7 +2518,7 @@ class AstClassPackage final : public AstNodeModule {
 public:
     AstClassPackage(FileLine* fl, const string& name)
         : ASTGEN_SUPER_ClassPackage(fl, name) {}
-    ASTGEN_MEMBERS_ClassPackage;
+    ASTGEN_MEMBERS_AstClassPackage;
     string verilogKwd() const override { return "classpackage"; }
     const char* broken() const override;
     void cloneRelink() override;
@@ -2531,7 +2531,7 @@ class AstIface final : public AstNodeModule {
 public:
     AstIface(FileLine* fl, const string& name)
         : ASTGEN_SUPER_Iface(fl, name) {}
-    ASTGEN_MEMBERS_Iface;
+    ASTGEN_MEMBERS_AstIface;
     // Interfaces have `timescale applicability but lots of code seems to
     // get false warnings if we enable this
     string verilogKwd() const override { return "interface"; }
@@ -2545,7 +2545,7 @@ public:
     AstModule(FileLine* fl, const string& name, bool program = false)
         : ASTGEN_SUPER_Module(fl, name)
         , m_isProgram{program} {}
-    ASTGEN_MEMBERS_Module;
+    ASTGEN_MEMBERS_AstModule;
     string verilogKwd() const override { return m_isProgram ? "program" : "module"; }
     bool timescaleMatters() const override { return true; }
 };
@@ -2554,7 +2554,7 @@ class AstNotFoundModule final : public AstNodeModule {
 public:
     AstNotFoundModule(FileLine* fl, const string& name)
         : ASTGEN_SUPER_NotFoundModule(fl, name) {}
-    ASTGEN_MEMBERS_NotFoundModule;
+    ASTGEN_MEMBERS_AstNotFoundModule;
     string verilogKwd() const override { return "/*not-found-*/ module"; }
     bool timescaleMatters() const override { return false; }
 };
@@ -2563,7 +2563,7 @@ class AstPackage final : public AstNodeModule {
 public:
     AstPackage(FileLine* fl, const string& name)
         : ASTGEN_SUPER_Package(fl, name) {}
-    ASTGEN_MEMBERS_Package;
+    ASTGEN_MEMBERS_AstPackage;
     string verilogKwd() const override { return "package"; }
     bool timescaleMatters() const override { return !isDollarUnit(); }
     static string dollarUnitName() { return AstNode::encodeName("$unit"); }
@@ -2574,7 +2574,7 @@ class AstPrimitive final : public AstNodeModule {
 public:
     AstPrimitive(FileLine* fl, const string& name)
         : ASTGEN_SUPER_Primitive(fl, name) {}
-    ASTGEN_MEMBERS_Primitive;
+    ASTGEN_MEMBERS_AstPrimitive;
     string verilogKwd() const override { return "primitive"; }
     bool timescaleMatters() const override { return false; }
 };
@@ -2589,7 +2589,7 @@ public:
         UASSERT_OBJ(!v3Global.assertDTypesResolved(), this,
                     "not coded to create after dtypes resolved");
     }
-    ASTGEN_MEMBERS_SelBit;
+    ASTGEN_MEMBERS_AstSelBit;
     AstNode* bitp() const { return rhsp(); }
 };
 class AstSelExtract final : public AstNodePreSel {
@@ -2597,7 +2597,7 @@ class AstSelExtract final : public AstNodePreSel {
 public:
     AstSelExtract(FileLine* fl, AstNode* fromp, AstNode* msbp, AstNode* lsbp)
         : ASTGEN_SUPER_SelExtract(fl, fromp, msbp, lsbp) {}
-    ASTGEN_MEMBERS_SelExtract;
+    ASTGEN_MEMBERS_AstSelExtract;
     AstNode* leftp() const { return rhsp(); }
     AstNode* rightp() const { return thsp(); }
 };
@@ -2607,7 +2607,7 @@ class AstSelMinus final : public AstNodePreSel {
 public:
     AstSelMinus(FileLine* fl, AstNode* fromp, AstNode* bitp, AstNode* widthp)
         : ASTGEN_SUPER_SelMinus(fl, fromp, bitp, widthp) {}
-    ASTGEN_MEMBERS_SelMinus;
+    ASTGEN_MEMBERS_AstSelMinus;
     AstNode* bitp() const { return rhsp(); }
     AstNode* widthp() const { return thsp(); }
 };
@@ -2617,7 +2617,7 @@ class AstSelPlus final : public AstNodePreSel {
 public:
     AstSelPlus(FileLine* fl, AstNode* fromp, AstNode* bitp, AstNode* widthp)
         : ASTGEN_SUPER_SelPlus(fl, fromp, bitp, widthp) {}
-    ASTGEN_MEMBERS_SelPlus;
+    ASTGEN_MEMBERS_AstSelPlus;
     AstNode* bitp() const { return rhsp(); }
     AstNode* widthp() const { return thsp(); }
 };
@@ -2633,7 +2633,7 @@ public:
         , m_keyword{keyword} {
         this->sensesp(sensesp);
     }
-    ASTGEN_MEMBERS_Always;
+    ASTGEN_MEMBERS_AstAlways;
     //
     void dump(std::ostream& str) const override;
     VAlwaysKwd keyword() const { return m_keyword; }
@@ -2646,7 +2646,7 @@ public:
         : ASTGEN_SUPER_AlwaysPost(fl, stmtsp) {
         this->sensesp(sensesp);
     }
-    ASTGEN_MEMBERS_AlwaysPost;
+    ASTGEN_MEMBERS_AstAlwaysPost;
 };
 class AstAlwaysPostponed final : public AstNodeProcedure {
     // Like always but postponement scheduling region
@@ -2654,19 +2654,19 @@ class AstAlwaysPostponed final : public AstNodeProcedure {
 public:
     AstAlwaysPostponed(FileLine* fl, AstNode* stmtsp)
         : ASTGEN_SUPER_AlwaysPostponed(fl, stmtsp) {}
-    ASTGEN_MEMBERS_AlwaysPostponed;
+    ASTGEN_MEMBERS_AstAlwaysPostponed;
 };
 class AstFinal final : public AstNodeProcedure {
 public:
     AstFinal(FileLine* fl, AstNode* stmtsp)
         : ASTGEN_SUPER_Final(fl, stmtsp) {}
-    ASTGEN_MEMBERS_Final;
+    ASTGEN_MEMBERS_AstFinal;
 };
 class AstInitial final : public AstNodeProcedure {
 public:
     AstInitial(FileLine* fl, AstNode* stmtsp)
         : ASTGEN_SUPER_Initial(fl, stmtsp) {}
-    ASTGEN_MEMBERS_Initial;
+    ASTGEN_MEMBERS_AstInitial;
 };
 class AstInitialAutomatic final : public AstNodeProcedure {
     // Automatic variable initialization
@@ -2674,7 +2674,7 @@ class AstInitialAutomatic final : public AstNodeProcedure {
 public:
     AstInitialAutomatic(FileLine* fl, AstNode* stmtsp)
         : ASTGEN_SUPER_InitialAutomatic(fl, stmtsp) {}
-    ASTGEN_MEMBERS_InitialAutomatic;
+    ASTGEN_MEMBERS_AstInitialAutomatic;
 };
 class AstInitialStatic final : public AstNodeProcedure {
     // Static variable initialization
@@ -2682,7 +2682,7 @@ class AstInitialStatic final : public AstNodeProcedure {
 public:
     AstInitialStatic(FileLine* fl, AstNode* stmtsp)
         : ASTGEN_SUPER_InitialStatic(fl, stmtsp) {}
-    ASTGEN_MEMBERS_InitialStatic;
+    ASTGEN_MEMBERS_AstInitialStatic;
 };
 
 // === AstNodeRange ===
@@ -2695,7 +2695,7 @@ public:
         : ASTGEN_SUPER_BracketRange(fl) {
         this->elementsp(elementsp);
     }
-    ASTGEN_MEMBERS_BracketRange;
+    ASTGEN_MEMBERS_AstBracketRange;
     virtual string emitC() { V3ERROR_NA_RETURN(""); }
     virtual string emitVerilog() { V3ERROR_NA_RETURN(""); }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -2715,7 +2715,7 @@ public:
     }
     inline AstRange(FileLine* fl, int left, int right);
     inline AstRange(FileLine* fl, const VNumRange& range);
-    ASTGEN_MEMBERS_Range;
+    ASTGEN_MEMBERS_AstRange;
     inline int leftConst() const;
     inline int rightConst() const;
     int hiConst() const {
@@ -2739,7 +2739,7 @@ class AstUnsizedRange final : public AstNodeRange {
 public:
     explicit AstUnsizedRange(FileLine* fl)
         : ASTGEN_SUPER_UnsizedRange(fl) {}
-    ASTGEN_MEMBERS_UnsizedRange;
+    ASTGEN_MEMBERS_AstUnsizedRange;
     virtual string emitC() { V3ERROR_NA_RETURN(""); }
     virtual string emitVerilog() { return "[]"; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -2749,7 +2749,7 @@ class AstWildcardRange final : public AstNodeRange {
 public:
     explicit AstWildcardRange(FileLine* fl)
         : ASTGEN_SUPER_WildcardRange(fl) {}
-    ASTGEN_MEMBERS_WildcardRange;
+    ASTGEN_MEMBERS_AstWildcardRange;
     virtual string emitC() { V3ERROR_NA_RETURN(""); }
     virtual string emitVerilog() { return "[*]"; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -2767,7 +2767,7 @@ public:
         addSensesp(sensesp);
         addStmtsp(stmtsp);
     }
-    ASTGEN_MEMBERS_AlwaysPublic;
+    ASTGEN_MEMBERS_AstAlwaysPublic;
     bool same(const AstNode* /*samep*/) const override { return true; }
     // Special accessors
     bool isJustOneBodyStmt() const { return stmtsp() && !stmtsp()->nextp(); }
@@ -2777,7 +2777,7 @@ class AstBreak final : public AstNodeStmt {
 public:
     explicit AstBreak(FileLine* fl)
         : ASTGEN_SUPER_Break(fl) {}
-    ASTGEN_MEMBERS_Break;
+    ASTGEN_MEMBERS_AstBreak;
     string verilogKwd() const override { return "break"; }
     bool isBrancher() const override {
         return true;  // SPECIAL: We don't process code after breaks
@@ -2793,7 +2793,7 @@ public:
         , m_sensesp{sensesp} {
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_CAwait;
+    ASTGEN_MEMBERS_AstCAwait;
     bool isTimingControl() const override { return true; }
     const char* broken() const override {
         BROKEN_RTN(m_sensesp && !m_sensesp->brokeExists());
@@ -2831,7 +2831,7 @@ public:
         this->fromp(fromp);
         this->addPinsp(pinsp);
     }
-    ASTGEN_MEMBERS_CMethodHard;
+    ASTGEN_MEMBERS_AstCMethodHard;
     string name() const override { return m_name; }  // * = Var name
     bool hasDType() const override { return true; }
     void name(const string& name) override { m_name = name; }
@@ -2854,7 +2854,7 @@ public:
         : ASTGEN_SUPER_CReset(fl) {
         this->varrefp(varrefp);
     }
-    ASTGEN_MEMBERS_CReset;
+    ASTGEN_MEMBERS_AstCReset;
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -2867,7 +2867,7 @@ public:
         : ASTGEN_SUPER_CReturn(fl) {
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_CReturn;
+    ASTGEN_MEMBERS_AstCReturn;
     int instrCount() const override { return widthInstrs(); }
     bool same(const AstNode* /*samep*/) const override { return true; }
 };
@@ -2880,7 +2880,7 @@ public:
         this->addExprsp(exprsp);
     }
     inline AstCStmt(FileLine* fl, const string& textStmt);
-    ASTGEN_MEMBERS_CStmt;
+    ASTGEN_MEMBERS_AstCStmt;
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -2895,7 +2895,7 @@ public:
         : ASTGEN_SUPER_Comment(fl)
         , m_showAt{showAt}
         , m_name{name} {}
-    ASTGEN_MEMBERS_Comment;
+    ASTGEN_MEMBERS_AstComment;
     string name() const override { return m_name; }  // * = Text
     bool same(const AstNode* samep) const override { return true; }  // Ignore name in comments
     virtual bool showAt() const { return m_showAt; }
@@ -2904,7 +2904,7 @@ class AstContinue final : public AstNodeStmt {
 public:
     explicit AstContinue(FileLine* fl)
         : ASTGEN_SUPER_Continue(fl) {}
-    ASTGEN_MEMBERS_Continue;
+    ASTGEN_MEMBERS_AstContinue;
     string verilogKwd() const override { return "continue"; }
     bool isBrancher() const override {
         return true;  // SPECIAL: We don't process code after breaks
@@ -2931,7 +2931,7 @@ public:
         , m_text{comment}
         , m_linescov{linescov}
         , m_offset{offset} {}
-    ASTGEN_MEMBERS_CoverDecl;
+    ASTGEN_MEMBERS_AstCoverDecl;
     const char* broken() const override {
         BROKEN_RTN(m_dataDeclp && !m_dataDeclp->brokeExists());
         if (m_dataDeclp && m_dataDeclp->m_dataDeclp) {  // Avoid O(n^2) accessing
@@ -2976,7 +2976,7 @@ public:
     AstCoverInc(FileLine* fl, AstCoverDecl* declp)
         : ASTGEN_SUPER_CoverInc(fl)
         , m_declp{declp} {}
-    ASTGEN_MEMBERS_CoverInc;
+    ASTGEN_MEMBERS_AstCoverInc;
     const char* broken() const override {
         BROKEN_RTN(!declp()->brokeExists());
         return nullptr;
@@ -3008,7 +3008,7 @@ public:
         this->origp(origp);
         this->changep(changep);
     }
-    ASTGEN_MEMBERS_CoverToggle;
+    ASTGEN_MEMBERS_AstCoverToggle;
     int instrCount() const override { return 3 + INSTR_COUNT_BRANCH + INSTR_COUNT_LD; }
     bool same(const AstNode* /*samep*/) const override { return true; }
     bool isGateOptimizable() const override { return false; }
@@ -3028,7 +3028,7 @@ public:
         this->lhsp(lhsp);
         this->addStmtsp(stmtsp);
     }
-    ASTGEN_MEMBERS_Delay;
+    ASTGEN_MEMBERS_AstDelay;
     bool isTimingControl() const override { return true; }
     bool same(const AstNode* /*samep*/) const override { return true; }
 };
@@ -3039,7 +3039,7 @@ public:
     AstDisable(FileLine* fl, const string& name)
         : ASTGEN_SUPER_Disable(fl)
         , m_name{name} {}
-    ASTGEN_MEMBERS_Disable;
+    ASTGEN_MEMBERS_AstDisable;
     string name() const override { return m_name; }  // * = Block name
     void name(const string& flag) override { m_name = flag; }
     bool isBrancher() const override {
@@ -3051,7 +3051,7 @@ class AstDisableFork final : public AstNodeStmt {
 public:
     explicit AstDisableFork(FileLine* fl)
         : ASTGEN_SUPER_DisableFork(fl) {}
-    ASTGEN_MEMBERS_DisableFork;
+    ASTGEN_MEMBERS_AstDisableFork;
 };
 class AstDisplay final : public AstNodeStmt {
     // Parents: stmtlist
@@ -3075,7 +3075,7 @@ public:
         this->fmtp(new AstSFormatF{fl, AstSFormatF::NoFormat(), exprsp, missingArgChar});
         this->filep(filep);
     }
-    ASTGEN_MEMBERS_Display;
+    ASTGEN_MEMBERS_AstDisplay;
     void dump(std::ostream& str) const override;
     const char* broken() const override {
         BROKEN_RTN(!fmtp());
@@ -3110,7 +3110,7 @@ public:
         , m_ctlType{ctlType} {
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_DumpCtl;
+    ASTGEN_MEMBERS_AstDumpCtl;
     string verilogKwd() const override { return ctlType().ascii(); }
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
@@ -3129,7 +3129,7 @@ public:
         this->sensesp(sensesp);
         this->addStmtsp(stmtsp);
     }
-    ASTGEN_MEMBERS_EventControl;
+    ASTGEN_MEMBERS_AstEventControl;
     string verilogKwd() const override { return "@(%l) %r"; }
     bool isTimingControl() const override { return true; }
     int instrCount() const override { return 0; }
@@ -3142,7 +3142,7 @@ public:
         : ASTGEN_SUPER_FClose(fl) {
         this->filep(filep);
     }
-    ASTGEN_MEMBERS_FClose;
+    ASTGEN_MEMBERS_AstFClose;
     string verilogKwd() const override { return "$fclose"; }
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
@@ -3159,7 +3159,7 @@ public:
         : ASTGEN_SUPER_FFlush(fl) {
         this->filep(filep);
     }
-    ASTGEN_MEMBERS_FFlush;
+    ASTGEN_MEMBERS_AstFFlush;
     string verilogKwd() const override { return "$fflush"; }
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
@@ -3180,7 +3180,7 @@ public:
         this->filenamep(filenamep);
         this->modep(modep);
     }
-    ASTGEN_MEMBERS_FOpen;
+    ASTGEN_MEMBERS_AstFOpen;
     string verilogKwd() const override { return "$fopen"; }
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
@@ -3199,7 +3199,7 @@ public:
         this->filep(filep);
         this->filenamep(filenamep);
     }
-    ASTGEN_MEMBERS_FOpenMcd;
+    ASTGEN_MEMBERS_AstFOpenMcd;
     string verilogKwd() const override { return "$fopen"; }
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
@@ -3212,7 +3212,7 @@ class AstFinish final : public AstNodeStmt {
 public:
     explicit AstFinish(FileLine* fl)
         : ASTGEN_SUPER_Finish(fl) {}
-    ASTGEN_MEMBERS_Finish;
+    ASTGEN_MEMBERS_AstFinish;
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
     bool isPure() const override { return false; }  // SPECIAL: $display has 'visual' ordering
@@ -3231,7 +3231,7 @@ public:
         , m_delayed{delayed} {
         this->operandp(operandp);
     }
-    ASTGEN_MEMBERS_FireEvent;
+    ASTGEN_MEMBERS_AstFireEvent;
     bool isDelayed() const { return m_delayed; }
 };
 class AstForeach final : public AstNodeStmt {
@@ -3243,7 +3243,7 @@ public:
         this->arrayp(arrayp);
         this->addStmtsp(stmtsp);
     }
-    ASTGEN_MEMBERS_Foreach;
+    ASTGEN_MEMBERS_AstForeach;
     bool isGateOptimizable() const override { return false; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -3266,7 +3266,7 @@ public:
     }
     const char* broken() const override;
     void cloneRelink() override;
-    ASTGEN_MEMBERS_JumpBlock;
+    ASTGEN_MEMBERS_AstJumpBlock;
     int instrCount() const override { return 0; }
     bool maybePointedTo() const override { return true; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -3286,7 +3286,7 @@ public:
     AstJumpGo(FileLine* fl, AstJumpLabel* labelp)
         : ASTGEN_SUPER_JumpGo(fl)
         , m_labelp{labelp} {}
-    ASTGEN_MEMBERS_JumpGo;
+    ASTGEN_MEMBERS_AstJumpGo;
     const char* broken() const override;
     void cloneRelink() override;
     void dump(std::ostream& str) const override;
@@ -3310,7 +3310,7 @@ public:
     AstJumpLabel(FileLine* fl, AstJumpBlock* blockp)
         : ASTGEN_SUPER_JumpLabel(fl)
         , m_blockp{blockp} {}
-    ASTGEN_MEMBERS_JumpLabel;
+    ASTGEN_MEMBERS_AstJumpLabel;
     bool maybePointedTo() const override { return true; }
     const char* broken() const override {
         BROKEN_RTN(!blockp()->brokeExistsAbove());
@@ -3334,7 +3334,7 @@ public:
     AstMonitorOff(FileLine* fl, bool off)
         : ASTGEN_SUPER_MonitorOff(fl)
         , m_off{off} {}
-    ASTGEN_MEMBERS_MonitorOff;
+    ASTGEN_MEMBERS_AstMonitorOff;
     string verilogKwd() const override { return m_off ? "$monitoroff" : "$monitoron"; }
     bool isGateOptimizable() const override { return false; }  // Though deleted before opt
     bool isPredictOptimizable() const override { return false; }  // Though deleted before opt
@@ -3353,7 +3353,7 @@ class AstPrintTimeScale final : public AstNodeStmt {
 public:
     explicit AstPrintTimeScale(FileLine* fl)
         : ASTGEN_SUPER_PrintTimeScale(fl) {}
-    ASTGEN_MEMBERS_PrintTimeScale;
+    ASTGEN_MEMBERS_AstPrintTimeScale;
     void name(const string& name) override { m_name = name; }
     string name() const override { return m_name; }  // * = Var name
     void dump(std::ostream& str) const override;
@@ -3374,7 +3374,7 @@ public:
         : ASTGEN_SUPER_Release(fl) {
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_Release;
+    ASTGEN_MEMBERS_AstRelease;
 };
 class AstRepeat final : public AstNodeStmt {
     // @astgen op1 := countp : AstNode
@@ -3385,7 +3385,7 @@ public:
         this->countp(countp);
         this->addStmtsp(stmtsp);
     }
-    ASTGEN_MEMBERS_Repeat;
+    ASTGEN_MEMBERS_AstRepeat;
     bool isGateOptimizable() const override { return false; }  // Not relevant - converted to FOR
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -3398,7 +3398,7 @@ public:
         : ASTGEN_SUPER_Return(fl) {
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_Return;
+    ASTGEN_MEMBERS_AstReturn;
     string verilogKwd() const override { return "return"; }
     bool isBrancher() const override {
         return true;  // SPECIAL: We don't process code after breaks
@@ -3420,7 +3420,7 @@ public:
         this->fmtp(new AstSFormatF{fl, AstSFormatF::NoFormat(), exprsp, missingArgChar});
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_SFormat;
+    ASTGEN_MEMBERS_AstSFormat;
     const char* broken() const override {
         BROKEN_RTN(!fmtp());
         return nullptr;
@@ -3438,7 +3438,7 @@ class AstStop final : public AstNodeStmt {
 public:
     AstStop(FileLine* fl, bool maybe)
         : ASTGEN_SUPER_Stop(fl) {}
-    ASTGEN_MEMBERS_Stop;
+    ASTGEN_MEMBERS_AstStop;
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
     bool isPure() const override { return false; }  // SPECIAL: $display has 'visual' ordering
@@ -3455,7 +3455,7 @@ public:
         : ASTGEN_SUPER_SysFuncAsTask(fl) {
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_SysFuncAsTask;
+    ASTGEN_MEMBERS_AstSysFuncAsTask;
     string verilogKwd() const override { return ""; }
     bool isGateOptimizable() const override { return true; }
     bool isPredictOptimizable() const override { return true; }
@@ -3471,7 +3471,7 @@ public:
         : ASTGEN_SUPER_SysIgnore(fl) {
         this->addExprsp(exprsp);
     }
-    ASTGEN_MEMBERS_SysIgnore;
+    ASTGEN_MEMBERS_AstSysIgnore;
     string verilogKwd() const override { return "$ignored"; }
     bool isGateOptimizable() const override { return false; }  // Though deleted before opt
     bool isPredictOptimizable() const override { return false; }  // Though deleted before opt
@@ -3487,7 +3487,7 @@ public:
         : ASTGEN_SUPER_SystemT(fl) {
         this->lhsp(lhsp);
     }
-    ASTGEN_MEMBERS_SystemT;
+    ASTGEN_MEMBERS_AstSystemT;
     string verilogKwd() const override { return "$system"; }
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
@@ -3511,7 +3511,7 @@ public:
         this->suffixp(suffixp);
         this->widthp(widthp);
     }
-    ASTGEN_MEMBERS_TimeFormat;
+    ASTGEN_MEMBERS_AstTimeFormat;
     string verilogKwd() const override { return "$timeformat"; }
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
@@ -3553,7 +3553,7 @@ public:
     }
     void dump(std::ostream& str) const override;
     int instrCount() const override { return 100; }  // Large...
-    ASTGEN_MEMBERS_TraceDecl;
+    ASTGEN_MEMBERS_AstTraceDecl;
     string name() const override { return m_showname; }
     bool maybePointedTo() const override { return true; }
     bool hasDType() const override { return true; }
@@ -3589,7 +3589,7 @@ public:
         this->valuep(
             declp->valuep()->cloneTree(true));  // TODO: maybe use reference to TraceDecl instead?
     }
-    ASTGEN_MEMBERS_TraceInc;
+    ASTGEN_MEMBERS_AstTraceInc;
     const char* broken() const override {
         BROKEN_RTN(!declp()->brokeExists());
         return nullptr;
@@ -3617,7 +3617,7 @@ public:
     AstTracePopNamePrefix(FileLine* fl, unsigned count)
         : ASTGEN_SUPER_TracePopNamePrefix(fl)
         , m_count{count} {}
-    ASTGEN_MEMBERS_TracePopNamePrefix;
+    ASTGEN_MEMBERS_AstTracePopNamePrefix;
     bool same(const AstNode* samep) const override { return false; }
     unsigned count() const { return m_count; }
 };
@@ -3627,7 +3627,7 @@ public:
     AstTracePushNamePrefix(FileLine* fl, const string& prefix)
         : ASTGEN_SUPER_TracePushNamePrefix(fl)
         , m_prefix{prefix} {}
-    ASTGEN_MEMBERS_TracePushNamePrefix;
+    ASTGEN_MEMBERS_AstTracePushNamePrefix;
     bool same(const AstNode* samep) const override { return false; }
     string prefix() const { return m_prefix; }
 };
@@ -3639,7 +3639,7 @@ public:
         : ASTGEN_SUPER_UCStmt(fl) {
         this->addExprsp(exprsp);
     }
-    ASTGEN_MEMBERS_UCStmt;
+    ASTGEN_MEMBERS_AstUCStmt;
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
     bool isPure() const override { return false; }
@@ -3655,7 +3655,7 @@ public:
         this->condp(condp);
         this->addStmtsp(stmtsp);
     }
-    ASTGEN_MEMBERS_Wait;
+    ASTGEN_MEMBERS_AstWait;
     bool isFirstInMyListOfStatements(AstNode* n) const override { return n == stmtsp(); }
     bool isTimingControl() const override { return true; }
 };
@@ -3664,7 +3664,7 @@ class AstWaitFork final : public AstNodeStmt {
 public:
     explicit AstWaitFork(FileLine* fl)
         : ASTGEN_SUPER_WaitFork(fl) {}
-    ASTGEN_MEMBERS_WaitFork;
+    ASTGEN_MEMBERS_AstWaitFork;
 };
 class AstWhile final : public AstNodeStmt {
     // @astgen op1 := precondsp : List[AstNode]
@@ -3678,7 +3678,7 @@ public:
         this->addStmtsp(stmtsp);
         this->addIncsp(incsp);
     }
-    ASTGEN_MEMBERS_While;
+    ASTGEN_MEMBERS_AstWhile;
     bool isGateOptimizable() const override { return false; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
     bool same(const AstNode* /*samep*/) const override { return true; }
@@ -3706,7 +3706,7 @@ public:
         this->valueArgRefp(valueArgRefp);
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_With;
+    ASTGEN_MEMBERS_AstWith;
     bool same(const AstNode* /*samep*/) const override { return true; }
     bool hasDType() const override { return true; }
     const char* broken() const override {
@@ -3729,7 +3729,7 @@ public:
         this->funcrefp(funcrefp);
         this->exprp(exprp);
     }
-    ASTGEN_MEMBERS_WithParse;
+    ASTGEN_MEMBERS_AstWithParse;
     bool same(const AstNode* /*samep*/) const override { return true; }
 };
 
@@ -3740,7 +3740,7 @@ public:
         : ASTGEN_SUPER_Assign(fl, lhsp, rhsp, timingControlp) {
         dtypeFrom(lhsp);
     }
-    ASTGEN_MEMBERS_Assign;
+    ASTGEN_MEMBERS_AstAssign;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         AstNode* const controlp = timingControlp() ? timingControlp()->cloneTree(false) : nullptr;
         return new AstAssign{fileline(), lhsp, rhsp, controlp};
@@ -3753,7 +3753,7 @@ class AstAssignAlias final : public AstNodeAssign {
 public:
     AstAssignAlias(FileLine* fl, AstVarRef* lhsp, AstVarRef* rhsp)
         : ASTGEN_SUPER_AssignAlias(fl, (AstNode*)lhsp, (AstNode*)rhsp) {}
-    ASTGEN_MEMBERS_AssignAlias;
+    ASTGEN_MEMBERS_AstAssignAlias;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { V3ERROR_NA_RETURN(nullptr); }
     bool brokeLhsMustBeLvalue() const override { return false; }
 };
@@ -3761,7 +3761,7 @@ class AstAssignDly final : public AstNodeAssign {
 public:
     AstAssignDly(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* timingControlp = nullptr)
         : ASTGEN_SUPER_AssignDly(fl, lhsp, rhsp, timingControlp) {}
-    ASTGEN_MEMBERS_AssignDly;
+    ASTGEN_MEMBERS_AstAssignDly;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         AstNode* const controlp = timingControlp() ? timingControlp()->cloneTree(false) : nullptr;
         return new AstAssignDly{fileline(), lhsp, rhsp, controlp};
@@ -3775,7 +3775,7 @@ class AstAssignForce final : public AstNodeAssign {
 public:
     AstAssignForce(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_AssignForce(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_AssignForce;
+    ASTGEN_MEMBERS_AstAssignForce;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAssignForce{this->fileline(), lhsp, rhsp};
     }
@@ -3786,7 +3786,7 @@ class AstAssignPost final : public AstNodeAssign {
 public:
     AstAssignPost(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_AssignPost(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_AssignPost;
+    ASTGEN_MEMBERS_AstAssignPost;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAssignPost(this->fileline(), lhsp, rhsp);
     }
@@ -3797,7 +3797,7 @@ class AstAssignPre final : public AstNodeAssign {
 public:
     AstAssignPre(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
         : ASTGEN_SUPER_AssignPre(fl, lhsp, rhsp) {}
-    ASTGEN_MEMBERS_AssignPre;
+    ASTGEN_MEMBERS_AstAssignPre;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAssignPre(this->fileline(), lhsp, rhsp);
     }
@@ -3810,7 +3810,7 @@ public:
         : ASTGEN_SUPER_AssignVarScope(fl, lhsp, rhsp) {
         dtypeFrom(rhsp);
     }
-    ASTGEN_MEMBERS_AssignVarScope;
+    ASTGEN_MEMBERS_AstAssignVarScope;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         return new AstAssignVarScope(this->fileline(), lhsp, rhsp);
     }
@@ -3822,7 +3822,7 @@ class AstAssignW final : public AstNodeAssign {
 public:
     AstAssignW(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* timingControlp = nullptr)
         : ASTGEN_SUPER_AssignW(fl, lhsp, rhsp, timingControlp) {}
-    ASTGEN_MEMBERS_AssignW;
+    ASTGEN_MEMBERS_AstAssignW;
     AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override {
         AstNode* const controlp = timingControlp() ? timingControlp()->cloneTree(false) : nullptr;
         return new AstAssignW{fileline(), lhsp, rhsp, controlp};
@@ -3842,7 +3842,7 @@ class AstCCall final : public AstNodeCCall {
 public:
     AstCCall(FileLine* fl, AstCFunc* funcp, AstNode* argsp = nullptr)
         : ASTGEN_SUPER_CCall(fl, funcp, argsp) {}
-    ASTGEN_MEMBERS_CCall;
+    ASTGEN_MEMBERS_AstCCall;
 
     string selfPointer() const { return m_selfPointer; }
     void selfPointer(const string& value) { m_selfPointer = value; }
@@ -3857,7 +3857,7 @@ public:
         : ASTGEN_SUPER_CMethodCall(fl, funcp, argsp) {
         this->fromp(fromp);
     }
-    ASTGEN_MEMBERS_CMethodCall;
+    ASTGEN_MEMBERS_AstCMethodCall;
     const char* broken() const override {
         BROKEN_BASE_RTN(AstNodeCCall::broken());
         BROKEN_RTN(!fromp());
@@ -3874,7 +3874,7 @@ public:
         statement(false);
     }
     bool hasDType() const override { return true; }
-    ASTGEN_MEMBERS_CNew;
+    ASTGEN_MEMBERS_AstCNew;
 };
 
 // === AstNodeCase ===
@@ -3892,7 +3892,7 @@ public:
     AstCase(FileLine* fl, VCaseType casex, AstNode* exprp, AstCaseItem* itemsp)
         : ASTGEN_SUPER_Case(fl, exprp, itemsp)
         , m_casex{casex} {}
-    ASTGEN_MEMBERS_Case;
+    ASTGEN_MEMBERS_AstCase;
     string verilogKwd() const override { return casez() ? "casez" : casex() ? "casex" : "case"; }
     bool same(const AstNode* samep) const override {
         return m_casex == static_cast<const AstCase*>(samep)->m_casex;
@@ -3919,14 +3919,14 @@ class AstGenCase final : public AstNodeCase {
 public:
     AstGenCase(FileLine* fl, AstNode* exprp, AstCaseItem* itemsp)
         : ASTGEN_SUPER_GenCase(fl, exprp, itemsp) {}
-    ASTGEN_MEMBERS_GenCase;
+    ASTGEN_MEMBERS_AstGenCase;
 };
 
 // === AstNodeCoverOrAssert ===
 class AstAssert final : public AstNodeCoverOrAssert {
     // @astgen op3 := failsp: List[AstNode] // Statments when propp is failing/falsey
 public:
-    ASTGEN_MEMBERS_Assert;
+    ASTGEN_MEMBERS_AstAssert;
     AstAssert(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp, bool immediate,
               const string& name = "")
         : ASTGEN_SUPER_Assert(fl, propp, passsp, immediate, name) {
@@ -3937,7 +3937,7 @@ class AstAssertIntrinsic final : public AstNodeCoverOrAssert {
     // A $cast or other compiler inserted assert, that must run even without --assert option
     // @astgen op3 := failsp: List[AstNode] // Statments when propp is failing/falsey
 public:
-    ASTGEN_MEMBERS_AssertIntrinsic;
+    ASTGEN_MEMBERS_AstAssertIntrinsic;
     AstAssertIntrinsic(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp,
                        bool immediate, const string& name = "")
         : ASTGEN_SUPER_AssertIntrinsic(fl, propp, passsp, immediate, name) {
@@ -3947,7 +3947,7 @@ public:
 class AstCover final : public AstNodeCoverOrAssert {
     // @astgen op3 := coverincsp: List[AstNode] // Coverage node
 public:
-    ASTGEN_MEMBERS_Cover;
+    ASTGEN_MEMBERS_AstCover;
     AstCover(FileLine* fl, AstNode* propp, AstNode* stmtsp, bool immediate,
              const string& name = "")
         : ASTGEN_SUPER_Cover(fl, propp, stmtsp, immediate, name) {}
@@ -3955,7 +3955,7 @@ public:
 };
 class AstRestrict final : public AstNodeCoverOrAssert {
 public:
-    ASTGEN_MEMBERS_Restrict;
+    ASTGEN_MEMBERS_AstRestrict;
     AstRestrict(FileLine* fl, AstNode* propp)
         : ASTGEN_SUPER_Restrict(fl, propp, nullptr, false, "") {}
 };
@@ -3968,7 +3968,7 @@ public:
         : ASTGEN_SUPER_FuncRef(fl, false, namep, pinsp) {}
     AstFuncRef(FileLine* fl, const string& name, AstNode* pinsp)
         : ASTGEN_SUPER_FuncRef(fl, false, name, pinsp) {}
-    ASTGEN_MEMBERS_FuncRef;
+    ASTGEN_MEMBERS_AstFuncRef;
     bool hasDType() const override { return true; }
 };
 class AstMethodCall final : public AstNodeFTaskRef {
@@ -3989,7 +3989,7 @@ public:
         : ASTGEN_SUPER_MethodCall(fl, false, name, pinsp) {
         this->fromp(fromp);
     }
-    ASTGEN_MEMBERS_MethodCall;
+    ASTGEN_MEMBERS_AstMethodCall;
     const char* broken() const override {
         BROKEN_BASE_RTN(AstNodeFTaskRef::broken());
         BROKEN_RTN(!fromp());
@@ -4010,7 +4010,7 @@ class AstNew final : public AstNodeFTaskRef {
 public:
     AstNew(FileLine* fl, AstNode* pinsp)
         : ASTGEN_SUPER_New(fl, false, "new", pinsp) {}
-    ASTGEN_MEMBERS_New;
+    ASTGEN_MEMBERS_AstNew;
     virtual bool cleanOut() const { return true; }
     bool same(const AstNode* /*samep*/) const override { return true; }
     bool hasDType() const override { return true; }
@@ -4025,7 +4025,7 @@ public:
     }
     AstTaskRef(FileLine* fl, const string& name, AstNode* pinsp)
         : ASTGEN_SUPER_TaskRef(fl, true, name, pinsp) {}
-    ASTGEN_MEMBERS_TaskRef;
+    ASTGEN_MEMBERS_AstTaskRef;
 };
 
 // === AstNodeFor ===
@@ -4033,7 +4033,7 @@ class AstGenFor final : public AstNodeFor {
 public:
     AstGenFor(FileLine* fl, AstNode* initsp, AstNode* condp, AstNode* incsp, AstNode* stmtsp)
         : ASTGEN_SUPER_GenFor(fl, initsp, condp, incsp, stmtsp) {}
-    ASTGEN_MEMBERS_GenFor;
+    ASTGEN_MEMBERS_AstGenFor;
 };
 
 // === AstNodeIf ===
@@ -4041,7 +4041,7 @@ class AstGenIf final : public AstNodeIf {
 public:
     AstGenIf(FileLine* fl, AstNode* condp, AstNode* thensp, AstNode* elsesp)
         : ASTGEN_SUPER_GenIf(fl, condp, thensp, elsesp) {}
-    ASTGEN_MEMBERS_GenIf;
+    ASTGEN_MEMBERS_AstGenIf;
 };
 class AstIf final : public AstNodeIf {
 private:
@@ -4051,7 +4051,7 @@ private:
 public:
     AstIf(FileLine* fl, AstNode* condp, AstNode* thensp = nullptr, AstNode* elsesp = nullptr)
         : ASTGEN_SUPER_If(fl, condp, thensp, elsesp) {}
-    ASTGEN_MEMBERS_If;
+    ASTGEN_MEMBERS_AstIf;
     bool uniquePragma() const { return m_uniquePragma; }
     void uniquePragma(bool flag) { m_uniquePragma = flag; }
     bool unique0Pragma() const { return m_unique0Pragma; }
@@ -4066,7 +4066,7 @@ public:
     AstReadMem(FileLine* fl, bool hex, AstNode* filenamep, AstNode* memp, AstNode* lsbp,
                AstNode* msbp)
         : ASTGEN_SUPER_ReadMem(fl, hex, filenamep, memp, lsbp, msbp) {}
-    ASTGEN_MEMBERS_ReadMem;
+    ASTGEN_MEMBERS_AstReadMem;
     string verilogKwd() const override { return (isHex() ? "$readmemh" : "$readmemb"); }
     const char* cFuncPrefixp() const override { return "VL_READMEM_"; }
 };
@@ -4075,7 +4075,7 @@ public:
     AstWriteMem(FileLine* fl, bool hex, AstNode* filenamep, AstNode* memp, AstNode* lsbp,
                 AstNode* msbp)
         : ASTGEN_SUPER_WriteMem(fl, hex, filenamep, memp, lsbp, msbp) {}
-    ASTGEN_MEMBERS_WriteMem;
+    ASTGEN_MEMBERS_AstWriteMem;
     string verilogKwd() const override { return (isHex() ? "$writememh" : "$writememb"); }
     const char* cFuncPrefixp() const override { return "VL_WRITEMEM_"; }
 };
@@ -4085,7 +4085,7 @@ class AstScCtor final : public AstNodeText {
 public:
     AstScCtor(FileLine* fl, const string& textp)
         : ASTGEN_SUPER_ScCtor(fl, textp) {}
-    ASTGEN_MEMBERS_ScCtor;
+    ASTGEN_MEMBERS_AstScCtor;
     bool isPure() const override { return false; }  // SPECIAL: User may order w/other sigs
     bool isOutputter() const override { return true; }
 };
@@ -4093,7 +4093,7 @@ class AstScDtor final : public AstNodeText {
 public:
     AstScDtor(FileLine* fl, const string& textp)
         : ASTGEN_SUPER_ScDtor(fl, textp) {}
-    ASTGEN_MEMBERS_ScDtor;
+    ASTGEN_MEMBERS_AstScDtor;
     bool isPure() const override { return false; }  // SPECIAL: User may order w/other sigs
     bool isOutputter() const override { return true; }
 };
@@ -4101,7 +4101,7 @@ class AstScHdr final : public AstNodeText {
 public:
     AstScHdr(FileLine* fl, const string& textp)
         : ASTGEN_SUPER_ScHdr(fl, textp) {}
-    ASTGEN_MEMBERS_ScHdr;
+    ASTGEN_MEMBERS_AstScHdr;
     bool isPure() const override { return false; }  // SPECIAL: User may order w/other sigs
     bool isOutputter() const override { return true; }
 };
@@ -4109,7 +4109,7 @@ class AstScImp final : public AstNodeText {
 public:
     AstScImp(FileLine* fl, const string& textp)
         : ASTGEN_SUPER_ScImp(fl, textp) {}
-    ASTGEN_MEMBERS_ScImp;
+    ASTGEN_MEMBERS_AstScImp;
     bool isPure() const override { return false; }  // SPECIAL: User may order w/other sigs
     bool isOutputter() const override { return true; }
 };
@@ -4117,7 +4117,7 @@ class AstScImpHdr final : public AstNodeText {
 public:
     AstScImpHdr(FileLine* fl, const string& textp)
         : ASTGEN_SUPER_ScImpHdr(fl, textp) {}
-    ASTGEN_MEMBERS_ScImpHdr;
+    ASTGEN_MEMBERS_AstScImpHdr;
     bool isPure() const override { return false; }  // SPECIAL: User may order w/other sigs
     bool isOutputter() const override { return true; }
 };
@@ -4125,7 +4125,7 @@ class AstScInt final : public AstNodeText {
 public:
     AstScInt(FileLine* fl, const string& textp)
         : ASTGEN_SUPER_ScInt(fl, textp) {}
-    ASTGEN_MEMBERS_ScInt;
+    ASTGEN_MEMBERS_AstScInt;
     bool isPure() const override { return false; }  // SPECIAL: User may order w/other sigs
     bool isOutputter() const override { return true; }
 };
@@ -4135,7 +4135,7 @@ class AstText final : public AstNodeSimpleText {
 public:
     AstText(FileLine* fl, const string& textp, bool tracking = false)
         : ASTGEN_SUPER_Text(fl, textp, tracking) {}
-    ASTGEN_MEMBERS_Text;
+    ASTGEN_MEMBERS_AstText;
 };
 class AstTextBlock final : public AstNodeSimpleText {
     // @astgen op1 := nodesp : List[AstNode]
@@ -4145,7 +4145,7 @@ public:
                           bool commas = false)
         : ASTGEN_SUPER_TextBlock(fl, textp, tracking)
         , m_commas(commas) {}
-    ASTGEN_MEMBERS_TextBlock;
+    ASTGEN_MEMBERS_AstTextBlock;
     void commas(bool flag) { m_commas = flag; }
     bool commas() const { return m_commas; }
     void addText(FileLine* fl, const string& textp, bool tracking = false) {
diff --git a/src/V3Dfg.cpp b/src/V3Dfg.cpp
index 8c86710b8..e353c5b5c 100644
--- a/src/V3Dfg.cpp
+++ b/src/V3Dfg.cpp
@@ -208,8 +208,7 @@ class ExtractCyclicComponents final {
     // The extracted cyclic components
     std::vector<std::unique_ptr<DfgGraph>> m_components;
     // Map from 'variable vertex' -> 'component index' -> 'clone in that component'
-    std::unordered_map<const DfgVertexLValue*, std::unordered_map<size_t, DfgVertexLValue*>>
-        m_clones;
+    std::unordered_map<const DfgVertexVar*, std::unordered_map<size_t, DfgVertexVar*>> m_clones;
 
     // METHODS
 
@@ -285,7 +284,7 @@ class ExtractCyclicComponents final {
 
     void visitMergeSCCs(const DfgVertex& vtx, size_t targetComponent) {
         // We stop at variable boundaries, which is where we will split the graphs
-        if (vtx.is<DfgVarPacked>() || vtx.is<DfgVarArray>()) return;
+        if (vtx.is<DfgVertexVar>()) return;
 
         // Mark visited/move on if already visited
         if (!m_merged.insert(&vtx).second) return;
@@ -312,9 +311,9 @@ class ExtractCyclicComponents final {
     // Methods for extraction
 
     // Retrieve clone of vertex in the given component
-    DfgVertexLValue& getClone(DfgVertexLValue& vtx, size_t component) {
+    DfgVertexVar& getClone(DfgVertexVar& vtx, size_t component) {
         UASSERT_OBJ(m_state.at(&vtx).component != component, &vtx, "Vertex is in that component");
-        DfgVertexLValue*& clonep = m_clones[&vtx][component];
+        DfgVertexVar*& clonep = m_clones[&vtx][component];
         if (!clonep) {
             DfgGraph& dfg = component == 0 ? m_dfg : *m_components[component - 1];
             if (DfgVarPacked* const pVtxp = vtx.cast<DfgVarPacked>()) {
@@ -322,7 +321,7 @@ class ExtractCyclicComponents final {
             } else if (DfgVarArray* const aVtxp = vtx.cast<DfgVarArray>()) {
                 clonep = new DfgVarArray{dfg, aVtxp->varp()};
             }
-            UASSERT_OBJ(clonep, &vtx, "Unhandled 'DfgVertexLValue' sub-type");
+            UASSERT_OBJ(clonep, &vtx, "Unhandled 'DfgVertexVar' sub-type");
             if (VL_UNLIKELY(m_doExpensiveChecks)) {
                 // Assign component number of clone for later checks
                 m_state
@@ -338,30 +337,30 @@ class ExtractCyclicComponents final {
         return *clonep;
     }
 
-    // Fix up non-variable sources of a DfgVertexLValue that are in a different component,
+    // Fix up non-variable sources of a DfgVertexVar that are in a different component,
     // using the provided 'relink' callback
     template <typename T_Vertex>
     void fixSources(T_Vertex& vtx, std::function<void(T_Vertex&, DfgVertex&, size_t)> relink) {
-        static_assert(std::is_base_of<DfgVertexLValue, T_Vertex>::value,
-                      "'Vertex' must be a 'DfgVertexLValue'");
+        static_assert(std::is_base_of<DfgVertexVar, T_Vertex>::value,
+                      "'Vertex' must be a 'DfgVertexVar'");
         const size_t component = m_state.at(&vtx).component;
         vtx.forEachSourceEdge([&](DfgEdge& edge, size_t idx) {
             DfgVertex& source = *edge.sourcep();
-            // DfgVertexLValue sources are fixed up by `fixSinks` on those sources
-            if (source.is<DfgVarPacked>() || source.is<DfgVarArray>()) return;
+            // DfgVertexVar sources are fixed up by `fixSinks` on those sources
+            if (source.is<DfgVertexVar>()) return;
             const size_t sourceComponent = m_state.at(&source).component;
             // Same component is OK
             if (sourceComponent == component) return;
             // Unlink the source edge (source is reconnected by 'relink'
             edge.unlinkSource();
             // Apply the fixup
-            DfgVertexLValue& clone = getClone(vtx, sourceComponent);
+            DfgVertexVar& clone = getClone(vtx, sourceComponent);
             relink(*(clone.as<T_Vertex>()), source, idx);
         });
     }
 
     // Fix up sinks of given variable vertex that are in a different component
-    void fixSinks(DfgVertexLValue& vtx) {
+    void fixSinks(DfgVertexVar& vtx) {
         const size_t component = m_state.at(&vtx).component;
         vtx.forEachSinkEdge([&](DfgEdge& edge) {
             const size_t sinkComponent = m_state.at(edge.sinkp()).component;
@@ -400,7 +399,7 @@ class ExtractCyclicComponents final {
             vtx.forEachSourceEdge([&](DfgEdge& edge, size_t) {
                 DfgVertex& source = *edge.sourcep();
                 // OK to cross at variables
-                if (source.is<DfgVarPacked>() || source.is<DfgVarArray>()) return;
+                if (source.is<DfgVertexVar>()) return;
                 UASSERT_OBJ(component == m_state.at(&source).component, &vtx,
                             "Component crossing edge without variable involvement");
             });
@@ -670,9 +669,7 @@ static void dumpDotVertexAndSourceEdges(std::ostream& os, const DfgVertex& vtx)
     vtx.forEachSourceEdge([&](const DfgEdge& edge, size_t idx) {  //
         if (edge.sourcep()) {
             string headLabel;
-            if (vtx.arity() > 1 || vtx.is<DfgVarPacked>() || vtx.is<DfgVarArray>()) {
-                headLabel = vtx.srcName(idx);
-            }
+            if (vtx.arity() > 1 || vtx.is<DfgVertexVar>()) headLabel = vtx.srcName(idx);
             dumpDotEdge(os, edge, headLabel);
         }
     });
@@ -843,7 +840,7 @@ void DfgEdge::relinkSource(DfgVertex* newSourcep) {
 // DfgVertex
 //------------------------------------------------------------------------------
 
-DfgVertex::DfgVertex(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type)
+DfgVertex::DfgVertex(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep)
     : m_filelinep{flp}
     , m_dtypep{dtypep}
     , m_type{type} {
@@ -897,7 +894,7 @@ V3Hash DfgVertex::hash(HashCache& cache) const {
         result += selfHash();
         // Variables are defined by themselves, so there is no need to hash the sources. This
         // enables sound hashing of graphs circular only through variables, which we rely on.
-        if (!is<DfgVarPacked>() && !is<DfgVarArray>()) {
+        if (!is<DfgVertexVar>()) {
             forEachSource([&result, &cache](const DfgVertex& src) { result += src.hash(cache); });
         }
     }
@@ -930,7 +927,6 @@ void DfgVertex::replaceWith(DfgVertex* newSorucep) {
 //------------------------------------------------------------------------------
 
 // DfgVarPacked ----------
-void DfgVarPacked::accept(DfgVisitor& visitor) { visitor.visit(this); }
 
 bool DfgVarPacked::selfEquals(const DfgVertex& that) const {
     if (const DfgVarPacked* otherp = that.cast<DfgVarPacked>()) {
@@ -943,7 +939,6 @@ bool DfgVarPacked::selfEquals(const DfgVertex& that) const {
 V3Hash DfgVarPacked::selfHash() const { return V3Hasher::uncachedHash(varp()); }
 
 // DfgVarPacked ----------
-void DfgVarArray::accept(DfgVisitor& visitor) { visitor.visit(this); }
 
 bool DfgVarArray::selfEquals(const DfgVertex& that) const {
     if (const DfgVarArray* otherp = that.cast<DfgVarArray>()) {
@@ -956,7 +951,6 @@ bool DfgVarArray::selfEquals(const DfgVertex& that) const {
 V3Hash DfgVarArray::selfHash() const { return V3Hasher::uncachedHash(varp()); }
 
 // DfgConst ----------
-void DfgConst::accept(DfgVisitor& visitor) { visitor.visit(this); }
 
 bool DfgConst::selfEquals(const DfgVertex& that) const {
     if (const DfgConst* otherp = that.cast<DfgConst>()) {
@@ -971,12 +965,4 @@ V3Hash DfgConst::selfHash() const { return V3Hasher::uncachedHash(m_constp); }
 // DfgVisitor
 //------------------------------------------------------------------------------
 
-void DfgVisitor::visit(DfgVarPacked* vtxp) { visit(static_cast<DfgVertex*>(vtxp)); }
-void DfgVisitor::visit(DfgVarArray* vtxp) { visit(static_cast<DfgVertex*>(vtxp)); }
-void DfgVisitor::visit(DfgConst* vtxp) { visit(static_cast<DfgVertex*>(vtxp)); }
-
-//------------------------------------------------------------------------------
-// 'astgen' generated definitions
-//------------------------------------------------------------------------------
-
-#include "V3Dfg__gen_definitions.h"
+#include "V3Dfg__gen_visitor_defns.h"  // From ./astgen
diff --git a/src/V3Dfg.h b/src/V3Dfg.h
index 1cfe8768e..e0745dad2 100644
--- a/src/V3Dfg.h
+++ b/src/V3Dfg.h
@@ -21,7 +21,7 @@
 // than the linked list based structures used by V3Graph.
 //
 // A bulk of the DfgVertex sub-types are generated by astgen, and are
-// analogous to the correspondign AstNode sub-types.
+// analogous to the corresponding AstNode sub-types.
 //
 // See also the internals documentation docs/internals.rst
 //
@@ -39,6 +39,8 @@
 #include "V3Hasher.h"
 #include "V3List.h"
 
+#include "V3Dfg__gen_forward_class_decls.h"  // From ./astgen
+
 #include <algorithm>
 #include <array>
 #include <functional>
@@ -46,7 +48,10 @@
 #include <unordered_map>
 #include <vector>
 
-class DfgVertex;
+#ifndef VL_NOT_FINAL
+#define VL_NOT_FINAL  // This #define fixes broken code folding in the CLion IDE
+#endif
+
 class DfgEdge;
 class DfgVisitor;
 
@@ -63,6 +68,25 @@ struct std::hash<std::pair<const DfgVertex*, const DfgVertex*>> final {
     }
 };
 
+//------------------------------------------------------------------------------
+// Dataflow vertex type enum
+//------------------------------------------------------------------------------
+
+class VDfgType final {
+public:
+#include "V3Dfg__gen_type_enum.h"  // From ./astgen
+    enum en m_e;
+    VDfgType() = default;
+    // cppcheck-suppress noExplicitConstructor
+    constexpr VDfgType(en _e)
+        : m_e{_e} {}
+    constexpr operator en() const { return m_e; }
+};
+constexpr bool operator==(VDfgType lhs, VDfgType rhs) { return lhs.m_e == rhs.m_e; }
+constexpr bool operator==(VDfgType lhs, VDfgType::en rhs) { return lhs.m_e == rhs; }
+constexpr bool operator==(VDfgType::en lhs, VDfgType rhs) { return lhs == rhs.m_e; }
+inline std::ostream& operator<<(std::ostream& os, const VDfgType& t) { return os << t.ascii(); }
+
 //------------------------------------------------------------------------------
 // Dataflow graph
 //------------------------------------------------------------------------------
@@ -191,9 +215,6 @@ public:
 // Dataflow graph vertex
 //------------------------------------------------------------------------------
 
-// Reuse the generated type constants
-using DfgType = VNType;
-
 // Base data flow graph vertex
 class DfgVertex VL_NOT_FINAL {
     friend class DfgGraph;
@@ -206,10 +227,10 @@ protected:
     DfgEdge* m_sinksp = nullptr;  // List of sinks of this vertex
     FileLine* const m_filelinep;  // Source location
     AstNodeDType* m_dtypep = nullptr;  // Data type of the result of this vertex
-    const DfgType m_type;
+    const VDfgType m_type;
 
     // CONSTRUCTOR
-    DfgVertex(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type);
+    DfgVertex(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep);
 
 public:
     virtual ~DfgVertex();
@@ -277,7 +298,7 @@ public:
     // The data type of the result of the nodes
     AstNodeDType* dtypep() const { return m_dtypep; }
     // The type of this vertex
-    DfgType type() const { return m_type; }
+    VDfgType type() const { return m_type; }
 
     // Width of result
     uint32_t width() const {
@@ -396,11 +417,18 @@ public:
     string warnMore() const { return fileline()->warnMore(); }
     string warnOther() const { return fileline()->warnOther(); }
 
+private:
+    // For internal use only.
+    // Note: specializations for particular vertex types are provided by 'astgen'
+    template <typename T>
+    inline static bool privateTypeTest(const DfgVertex* nodep);
+
+public:
     // Subtype test
     template <typename T>
     bool is() const {
         static_assert(std::is_base_of<DfgVertex, T>::value, "'T' must be a subtype of DfgVertex");
-        return m_type == T::dfgType();
+        return privateTypeTest<typename std::remove_cv<T>::type>(this);
     }
 
     // Ensure subtype, then cast to that type
@@ -436,367 +464,8 @@ public:
     virtual const string srcName(size_t idx) const = 0;
 };
 
-// DfgVertices are, well ... DfgVertices
-template <>
-constexpr bool DfgVertex::is<DfgVertex>() const {
-    return true;
-}
-template <>
-constexpr DfgVertex* DfgVertex::as<DfgVertex>() {
-    return this;
-}
-template <>
-constexpr const DfgVertex* DfgVertex::as<DfgVertex>() const {
-    return this;
-}
-template <>
-constexpr DfgVertex* DfgVertex::cast<DfgVertex>() {
-    return this;
-}
-template <>
-constexpr const DfgVertex* DfgVertex::cast<DfgVertex>() const {
-    return this;
-}
-
-template <size_t Arity>
-class DfgVertexWithArity VL_NOT_FINAL : public DfgVertex {
-    static_assert(1 <= Arity && Arity <= 4, "Arity must be between 1 and 4 inclusive");
-
-    std::array<DfgEdge, Arity> m_srcs;  // Source edges
-
-protected:
-    DfgVertexWithArity<Arity>(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type)
-        : DfgVertex{dfg, flp, dtypep, type} {
-        // Initialize source edges
-        for (size_t i = 0; i < Arity; ++i) m_srcs[i].init(this);
-    }
-
-    ~DfgVertexWithArity<Arity>() override = default;
-
-public:
-    std::pair<DfgEdge*, size_t> sourceEdges() override {  //
-        return {m_srcs.data(), Arity};
-    }
-    std::pair<const DfgEdge*, size_t> sourceEdges() const override {
-        return {m_srcs.data(), Arity};
-    }
-
-    template <size_t Index>
-    DfgEdge* sourceEdge() {
-        static_assert(Index < Arity, "Source index out of range");
-        return &m_srcs[Index];
-    }
-
-    template <size_t Index>
-    const DfgEdge* sourceEdge() const {
-        static_assert(Index < Arity, "Source index out of range");
-        return &m_srcs[Index];
-    }
-
-    template <size_t Index>
-    DfgVertex* source() const {
-        static_assert(Index < Arity, "Source index out of range");
-        return m_srcs[Index].sourcep();
-    }
-
-    template <size_t Index>
-    void relinkSource(DfgVertex* newSourcep) {
-        static_assert(Index < Arity, "Source index out of range");
-        UASSERT_OBJ(m_srcs[Index].sinkp() == this, this, "Inconsistent");
-        m_srcs[Index].relinkSource(newSourcep);
-    }
-
-    // Named source getter/setter for unary vertices
-    template <size_t A = Arity>
-    typename std::enable_if<A == 1, DfgVertex*>::type srcp() const {
-        static_assert(A == Arity, "Should not be changed");
-        return source<0>();
-    }
-    template <size_t A = Arity>
-    typename std::enable_if<A == 1, void>::type srcp(DfgVertex* vtxp) {
-        static_assert(A == Arity, "Should not be changed");
-        relinkSource<0>(vtxp);
-    }
-
-    // Named source getter/setter for binary vertices
-    template <size_t A = Arity>
-    typename std::enable_if<A == 2, DfgVertex*>::type lhsp() const {
-        static_assert(A == Arity, "Should not be changed");
-        return source<0>();
-    }
-    template <size_t A = Arity>
-    typename std::enable_if<A == 2, void>::type lhsp(DfgVertex* vtxp) {
-        static_assert(A == Arity, "Should not be changed");
-        relinkSource<0>(vtxp);
-    }
-
-    template <size_t A = Arity>
-    typename std::enable_if<A == 2, DfgVertex*>::type rhsp() const {
-        static_assert(A == Arity, "Should not be changed");
-        return source<1>();
-    }
-    template <size_t A = Arity>
-    typename std::enable_if<A == 2, void>::type rhsp(DfgVertex* vtxp) {
-        static_assert(A == Arity, "Should not be changed");
-        relinkSource<1>(vtxp);
-    }
-};
-
-class DfgVertexVariadic VL_NOT_FINAL : public DfgVertex {
-    DfgEdge* m_srcsp;  // The source edges
-    uint32_t m_srcCnt = 0;  // Number of sources used
-    uint32_t m_srcCap;  // Number of sources allocated
-
-    // Allocate a new source edge array
-    DfgEdge* allocSources(size_t n) {
-        DfgEdge* const srcsp = new DfgEdge[n];
-        for (size_t i = 0; i < n; ++i) srcsp[i].init(this);
-        return srcsp;
-    }
-
-    // Double the capacity of m_srcsp
-    void growSources() {
-        m_srcCap *= 2;
-        DfgEdge* const newsp = allocSources(m_srcCap);
-        for (size_t i = 0; i < m_srcCnt; ++i) {
-            DfgEdge* const oldp = m_srcsp + i;
-            // Skip over unlinked source edge
-            if (!oldp->sourcep()) continue;
-            // New edge driven from the same vertex as the old edge
-            newsp[i].relinkSource(oldp->sourcep());
-            // Unlink the old edge, it will be deleted
-            oldp->unlinkSource();
-        }
-        // Delete old source edges
-        delete[] m_srcsp;
-        // Keep hold of new source edges
-        m_srcsp = newsp;
-    }
-
-protected:
-    DfgVertexVariadic(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type,
-                      uint32_t initialCapacity = 1)
-        : DfgVertex{dfg, flp, dtypep, type}
-        , m_srcsp{allocSources(initialCapacity)}
-        , m_srcCap{initialCapacity} {}
-
-    ~DfgVertexVariadic() override { delete[] m_srcsp; };
-
-    DfgEdge* addSource() {
-        if (m_srcCnt == m_srcCap) growSources();
-        return m_srcsp + m_srcCnt++;
-    }
-
-    void resetSources() {
-        // #ifdef VL_DEBUG TODO: DEBUG ONLY
-        for (uint32_t i = 0; i < m_srcCnt; ++i) {
-            UASSERT_OBJ(!m_srcsp[i].sourcep(), m_srcsp[i].sourcep(), "Connected source");
-        }
-        // #endif
-        m_srcCnt = 0;
-    }
-
-public:
-    DfgEdge* sourceEdge(size_t idx) const { return &m_srcsp[idx]; }
-    DfgVertex* source(size_t idx) const { return m_srcsp[idx].sourcep(); }
-
-    std::pair<DfgEdge*, size_t> sourceEdges() override { return {m_srcsp, m_srcCnt}; }
-    std::pair<const DfgEdge*, size_t> sourceEdges() const override { return {m_srcsp, m_srcCnt}; }
-};
-
-//------------------------------------------------------------------------------
-// Vertex classes
-//------------------------------------------------------------------------------
-
-class DfgVertexLValue VL_NOT_FINAL : public DfgVertexVariadic {
-    AstVar* const m_varp;  // The AstVar associated with this vertex (not owned by this vertex)
-    bool m_hasModRefs = false;  // This AstVar is referenced outside the DFG, but in the module
-    bool m_hasExtRefs = false;  // This AstVar is referenced from outside the module
-
-public:
-    DfgVertexLValue(DfgGraph& dfg, DfgType type, AstVar* varp, uint32_t initialCapacity)
-        : DfgVertexVariadic{dfg, varp->fileline(), dtypeFor(varp), type, initialCapacity}
-        , m_varp{varp} {}
-
-    AstVar* varp() const { return m_varp; }
-    bool hasModRefs() const { return m_hasModRefs; }
-    void setHasModRefs() { m_hasModRefs = true; }
-    bool hasExtRefs() const { return m_hasExtRefs; }
-    void setHasExtRefs() { m_hasExtRefs = true; }
-    bool hasRefs() const { return m_hasModRefs || m_hasExtRefs; }
-
-    // Variable cannot be removed, even if redundant in the DfgGraph (might be used externally)
-    bool keep() const {
-        // Keep if referenced outside this module
-        if (hasExtRefs()) return true;
-        // Keep if traced
-        if (v3Global.opt.trace() && varp()->isTrace()) return true;
-        // Keep if public
-        if (varp()->isSigPublic()) return true;
-        // Otherwise it can be removed
-        return false;
-    }
-};
-
-class DfgVarPacked final : public DfgVertexLValue {
-    friend class DfgVertex;
-    friend class DfgVisitor;
-
-    using DriverData = std::pair<FileLine*, uint32_t>;
-
-    std::vector<DriverData> m_driverData;  // Additional data associate with each driver
-
-    void accept(DfgVisitor& visitor) override;
-    bool selfEquals(const DfgVertex& that) const override;
-    V3Hash selfHash() const override;
-    static constexpr DfgType dfgType() { return DfgType::atVar; };
-
-public:
-    DfgVarPacked(DfgGraph& dfg, AstVar* varp)
-        : DfgVertexLValue{dfg, dfgType(), varp, 1u} {}
-
-    bool isDrivenByDfg() const { return arity() > 0; }
-    bool isDrivenFullyByDfg() const { return arity() == 1 && source(0)->dtypep() == dtypep(); }
-
-    void addDriver(FileLine* flp, uint32_t lsb, DfgVertex* vtxp) {
-        m_driverData.emplace_back(flp, lsb);
-        DfgVertexVariadic::addSource()->relinkSource(vtxp);
-    }
-
-    void resetSources() {
-        m_driverData.clear();
-        DfgVertexVariadic::resetSources();
-    }
-
-    // Remove undriven sources
-    void packSources() {
-        // Grab and reset the driver data
-        std::vector<DriverData> driverData{std::move(m_driverData)};
-
-        // Grab and unlink the sources
-        std::vector<DfgVertex*> sources{arity()};
-        forEachSourceEdge([&](DfgEdge& edge, size_t idx) {
-            sources[idx] = edge.sourcep();
-            edge.unlinkSource();
-        });
-        DfgVertexVariadic::resetSources();
-
-        // Add back the driven sources
-        for (size_t i = 0; i < sources.size(); ++i) {
-            if (!sources[i]) continue;
-            addDriver(driverData[i].first, driverData[i].second, sources[i]);
-        }
-    }
-
-    FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; }
-    uint32_t driverLsb(size_t idx) const { return m_driverData[idx].second; }
-
-    const string srcName(size_t idx) const override {
-        return isDrivenFullyByDfg() ? "" : cvtToStr(driverLsb(idx));
-    }
-};
-
-class DfgVarArray final : public DfgVertexLValue {
-    friend class DfgVertex;
-    friend class DfgVisitor;
-
-    using DriverData = std::pair<FileLine*, uint32_t>;
-
-    std::vector<DriverData> m_driverData;  // Additional data associate with each driver
-
-    void accept(DfgVisitor& visitor) override;
-    bool selfEquals(const DfgVertex& that) const override;
-    V3Hash selfHash() const override;
-    static constexpr DfgType dfgType() { return DfgType::atUnpackArrayDType; };  // TODO: gross
-
-public:
-    DfgVarArray(DfgGraph& dfg, AstVar* varp)
-        : DfgVertexLValue{dfg, dfgType(), varp, 4u} {
-        UASSERT_OBJ(VN_IS(varp->dtypeSkipRefp(), UnpackArrayDType), varp, "Non array DfgVarArray");
-    }
-
-    bool isDrivenByDfg() const { return arity() > 0; }
-
-    void addDriver(FileLine* flp, uint32_t index, DfgVertex* vtxp) {
-        m_driverData.emplace_back(flp, index);
-        DfgVertexVariadic::addSource()->relinkSource(vtxp);
-    }
-
-    void resetSources() {
-        m_driverData.clear();
-        DfgVertexVariadic::resetSources();
-    }
-
-    // Remove undriven sources
-    void packSources() {
-        // Grab and reset the driver data
-        std::vector<DriverData> driverData{std::move(m_driverData)};
-
-        // Grab and unlink the sources
-        std::vector<DfgVertex*> sources{arity()};
-        forEachSourceEdge([&](DfgEdge& edge, size_t idx) {
-            sources[idx] = edge.sourcep();
-            edge.unlinkSource();
-        });
-        DfgVertexVariadic::resetSources();
-
-        // Add back the driven sources
-        for (size_t i = 0; i < sources.size(); ++i) {
-            if (!sources[i]) continue;
-            addDriver(driverData[i].first, driverData[i].second, sources[i]);
-        }
-    }
-
-    FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; }
-    uint32_t driverIndex(size_t idx) const { return m_driverData[idx].second; }
-
-    DfgVertex* driverAt(size_t idx) const {
-        const DfgEdge* const edgep = findSourceEdge([=](const DfgEdge&, size_t i) {  //
-            return driverIndex(i) == idx;
-        });
-        return edgep ? edgep->sourcep() : nullptr;
-    }
-
-    const string srcName(size_t idx) const override { return cvtToStr(driverIndex(idx)); }
-};
-
-class DfgConst final : public DfgVertex {
-    friend class DfgVertex;
-    friend class DfgVisitor;
-
-    AstConst* const m_constp;  // The AstConst associated with this vertex (owned by this vertex)
-
-    void accept(DfgVisitor& visitor) override;
-    bool selfEquals(const DfgVertex& that) const override;
-    V3Hash selfHash() const override;
-    static constexpr DfgType dfgType() { return DfgType::atConst; };
-
-public:
-    DfgConst(DfgGraph& dfg, AstConst* constp)
-        : DfgVertex{dfg, constp->fileline(), dtypeFor(constp), dfgType()}
-        , m_constp{constp} {}
-
-    ~DfgConst() override { VL_DO_DANGLING(m_constp->deleteTree(), m_constp); }
-
-    AstConst* constp() const { return m_constp; }
-    V3Number& num() const { return m_constp->num(); }
-
-    uint32_t toU32() const { return num().toUInt(); }
-    int32_t toI32() const { return num().toSInt(); }
-
-    bool isZero() const { return num().isEqZero(); }
-    bool isOnes() const { return num().isEqAllOnes(width()); }
-
-    std::pair<DfgEdge*, size_t> sourceEdges() override { return {nullptr, 0}; }
-    std::pair<const DfgEdge*, size_t> sourceEdges() const override { return {nullptr, 0}; }
-    const string srcName(size_t) const override {  // LCOV_EXCL_START
-        VL_UNREACHABLE;
-        return "";
-    }  // LCOV_EXCL_STOP
-};
-
-// The rest of the DfgVertex subclasses are generated by 'astgen' from AstNodeMath nodes
-#include "V3Dfg__gen_vertex_classes.h"
+// Specialisations of privateTypeTest
+#include "V3Dfg__gen_type_tests.h"  // From ./astgen
 
 //------------------------------------------------------------------------------
 // Dfg vertex visitor
@@ -807,10 +476,8 @@ public:
     // Dispatch to most specific 'visit' method on 'vtxp'
     void iterate(DfgVertex* vtxp) { vtxp->accept(*this); }
 
-    virtual void visit(DfgVarPacked* vtxp);
-    virtual void visit(DfgVarArray* vtxp);
-    virtual void visit(DfgConst* vtxp);
-#include "V3Dfg__gen_visitor_decls.h"
+    virtual void visit(DfgVertex* nodep) = 0;
+#include "V3Dfg__gen_visitor_decls.h"  // From ./astgen
 };
 
 //------------------------------------------------------------------------------
@@ -937,6 +604,180 @@ Vertex* DfgVertex::findSink() const {
     return findSink<Vertex>([](const Vertex&) { return true; });
 }
 
+//------------------------------------------------------------------------------
+// DfgVertex sub-types follow
+//------------------------------------------------------------------------------
+
+// Include macros generated by 'astgen'. These include DFGGEN_MEMBERS_<Node>
+// for each DfgVertex sub-type. The generated members include boilerplate
+// methods related to cloning, visitor dispatch, and other functionality.
+// For precise details please read the generated macros.
+#include "V3Dfg__gen_macros.h"
+
+//------------------------------------------------------------------------------
+// Implementation of dataflow graph vertices with a fixed number of sources
+//------------------------------------------------------------------------------
+
+template <size_t Arity>
+class DfgVertexWithArity VL_NOT_FINAL : public DfgVertex {
+    static_assert(1 <= Arity && Arity <= 4, "Arity must be between 1 and 4 inclusive");
+
+    std::array<DfgEdge, Arity> m_srcs;  // Source edges
+
+protected:
+    DfgVertexWithArity<Arity>(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep)
+        : DfgVertex{dfg, type, flp, dtypep} {
+        // Initialize source edges
+        for (size_t i = 0; i < Arity; ++i) m_srcs[i].init(this);
+    }
+
+    ~DfgVertexWithArity<Arity>() override = default;
+
+public:
+    std::pair<DfgEdge*, size_t> sourceEdges() final override {  //
+        return {m_srcs.data(), Arity};
+    }
+    std::pair<const DfgEdge*, size_t> sourceEdges() const final override {
+        return {m_srcs.data(), Arity};
+    }
+
+    template <size_t Index>
+    DfgEdge* sourceEdge() {
+        static_assert(Index < Arity, "Source index out of range");
+        return &m_srcs[Index];
+    }
+
+    template <size_t Index>
+    const DfgEdge* sourceEdge() const {
+        static_assert(Index < Arity, "Source index out of range");
+        return &m_srcs[Index];
+    }
+
+    template <size_t Index>
+    DfgVertex* source() const {
+        static_assert(Index < Arity, "Source index out of range");
+        return m_srcs[Index].sourcep();
+    }
+
+    template <size_t Index>
+    void relinkSource(DfgVertex* newSourcep) {
+        static_assert(Index < Arity, "Source index out of range");
+        UASSERT_OBJ(m_srcs[Index].sinkp() == this, this, "Inconsistent");
+        m_srcs[Index].relinkSource(newSourcep);
+    }
+};
+
+class DfgVertexUnary VL_NOT_FINAL : public DfgVertexWithArity<1> {
+protected:
+    DfgVertexUnary(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep)
+        : DfgVertexWithArity<1>{dfg, type, flp, dtypep} {}
+
+public:
+    ASTGEN_MEMBERS_DfgVertexUnary;
+
+    // Named getter/setter for sources
+    DfgVertex* srcp() const { return source<0>(); }
+    void srcp(DfgVertex* vtxp) { relinkSource<0>(vtxp); }
+};
+
+class DfgVertexBinary VL_NOT_FINAL : public DfgVertexWithArity<2> {
+protected:
+    DfgVertexBinary(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep)
+        : DfgVertexWithArity<2>{dfg, type, flp, dtypep} {}
+
+public:
+    ASTGEN_MEMBERS_DfgVertexBinary;
+
+    // Named getter/setter for sources
+    DfgVertex* lhsp() const { return source<0>(); }
+    void lhsp(DfgVertex* vtxp) { relinkSource<0>(vtxp); }
+    DfgVertex* rhsp() const { return source<1>(); }
+    void rhsp(DfgVertex* vtxp) { relinkSource<1>(vtxp); }
+};
+
+class DfgVertexTernary VL_NOT_FINAL : public DfgVertexWithArity<3> {
+protected:
+    DfgVertexTernary(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep)
+        : DfgVertexWithArity<3>{dfg, type, flp, dtypep} {}
+
+public:
+    ASTGEN_MEMBERS_DfgVertexTernary;
+};
+
+//------------------------------------------------------------------------------
+// Implementation of dataflow graph vertices with a variable number of sources
+//------------------------------------------------------------------------------
+
+class DfgVertexVariadic VL_NOT_FINAL : public DfgVertex {
+    DfgEdge* m_srcsp;  // The source edges
+    uint32_t m_srcCnt = 0;  // Number of sources used
+    uint32_t m_srcCap;  // Number of sources allocated
+
+    // Allocate a new source edge array
+    DfgEdge* allocSources(size_t n) {
+        DfgEdge* const srcsp = new DfgEdge[n];
+        for (size_t i = 0; i < n; ++i) srcsp[i].init(this);
+        return srcsp;
+    }
+
+    // Double the capacity of m_srcsp
+    void growSources() {
+        m_srcCap *= 2;
+        DfgEdge* const newsp = allocSources(m_srcCap);
+        for (size_t i = 0; i < m_srcCnt; ++i) {
+            DfgEdge* const oldp = m_srcsp + i;
+            // Skip over unlinked source edge
+            if (!oldp->sourcep()) continue;
+            // New edge driven from the same vertex as the old edge
+            newsp[i].relinkSource(oldp->sourcep());
+            // Unlink the old edge, it will be deleted
+            oldp->unlinkSource();
+        }
+        // Delete old source edges
+        delete[] m_srcsp;
+        // Keep hold of new source edges
+        m_srcsp = newsp;
+    }
+
+protected:
+    DfgVertexVariadic(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep,
+                      uint32_t initialCapacity = 1)
+        : DfgVertex{dfg, type, flp, dtypep}
+        , m_srcsp{allocSources(initialCapacity)}
+        , m_srcCap{initialCapacity} {}
+
+    ~DfgVertexVariadic() override { delete[] m_srcsp; };
+
+    DfgEdge* addSource() {
+        if (m_srcCnt == m_srcCap) growSources();
+        return m_srcsp + m_srcCnt++;
+    }
+
+    void resetSources() {
+        // #ifdef VL_DEBUG TODO: DEBUG ONLY
+        for (uint32_t i = 0; i < m_srcCnt; ++i) {
+            UASSERT_OBJ(!m_srcsp[i].sourcep(), m_srcsp[i].sourcep(), "Connected source");
+        }
+        // #endif
+        m_srcCnt = 0;
+    }
+
+public:
+    ASTGEN_MEMBERS_DfgVertexVariadic;
+
+    DfgEdge* sourceEdge(size_t idx) const { return &m_srcsp[idx]; }
+    DfgVertex* source(size_t idx) const { return m_srcsp[idx].sourcep(); }
+
+    std::pair<DfgEdge*, size_t> sourceEdges() override { return {m_srcsp, m_srcCnt}; }
+    std::pair<const DfgEdge*, size_t> sourceEdges() const override { return {m_srcsp, m_srcCnt}; }
+};
+
+// DfgVertex subclasses
+#include "V3DfgVertices.h"
+
+// The rest of the DfgVertex subclasses are generated by 'astgen' from AstNodeMath nodes
+#include "V3Dfg__gen_auto_classes.h"
+
 bool DfgVertex::isZero() const {
     if (const DfgConst* const constp = cast<DfgConst>()) return constp->isZero();
     return false;
diff --git a/src/V3DfgAstToDfg.cpp b/src/V3DfgAstToDfg.cpp
index c63814f90..32344bdff 100644
--- a/src/V3DfgAstToDfg.cpp
+++ b/src/V3DfgAstToDfg.cpp
@@ -41,8 +41,8 @@ namespace {
 
 // Create a DfgVertex out of a AstNodeMath. For most AstNodeMath subtypes, this can be done
 // automatically. For the few special cases, we provide specializations below
-template <typename Vertex>
-Vertex* makeVertex(const AstForDfg<Vertex>* nodep, DfgGraph& dfg) {
+template <typename Vertex, typename Node>
+Vertex* makeVertex(const Node* nodep, DfgGraph& dfg) {
     return new Vertex{dfg, nodep->fileline(), DfgVertex::dtypeFor(nodep)};
 }
 
@@ -51,22 +51,22 @@ Vertex* makeVertex(const AstForDfg<Vertex>* nodep, DfgGraph& dfg) {
 // LCOV_EXCL_START
 // AstCCast changes width, but should not exists where DFG optimization is currently invoked
 template <>
-DfgCCast* makeVertex<DfgCCast>(const AstCCast*, DfgGraph&) {
+DfgCCast* makeVertex<DfgCCast, AstCCast>(const AstCCast*, DfgGraph&) {
     return nullptr;
 }
 // Unhandled in DfgToAst, but also operates on strings which we don't optimize anyway
 template <>
-DfgAtoN* makeVertex<DfgAtoN>(const AstAtoN*, DfgGraph&) {
+DfgAtoN* makeVertex<DfgAtoN, AstAtoN>(const AstAtoN*, DfgGraph&) {
     return nullptr;
 }
 // Unhandled in DfgToAst, but also operates on strings which we don't optimize anyway
 template <>
-DfgCompareNN* makeVertex<DfgCompareNN>(const AstCompareNN*, DfgGraph&) {
+DfgCompareNN* makeVertex<DfgCompareNN, AstCompareNN>(const AstCompareNN*, DfgGraph&) {
     return nullptr;
 }
 // Unhandled in DfgToAst, but also operates on unpacked arrays which we don't optimize anyway
 template <>
-DfgSliceSel* makeVertex<DfgSliceSel>(const AstSliceSel*, DfgGraph&) {
+DfgSliceSel* makeVertex<DfgSliceSel, AstSliceSel>(const AstSliceSel*, DfgGraph&) {
     return nullptr;
 }
 // LCOV_EXCL_STOP
@@ -105,11 +105,11 @@ class AstToDfgVisitor final : public VNVisitor {
         m_uncommittedVertices.clear();
     }
 
-    DfgVertexLValue* getNet(AstVar* varp) {
+    DfgVertexVar* getNet(AstVar* varp) {
         if (!varp->user1p()) {
-            // Note DfgVertexLValue vertices are not added to m_uncommittedVertices, because we
+            // Note DfgVertexVar vertices are not added to m_uncommittedVertices, because we
             // want to hold onto them via AstVar::user1p, and the AstVar might be referenced via
-            // multiple AstVarRef instances, so we will never revert a DfgVertexLValue once
+            // multiple AstVarRef instances, so we will never revert a DfgVertexVar once
             // created. We will delete unconnected variable vertices at the end.
             if (VN_IS(varp->dtypep()->skipRefp(), UnpackArrayDType)) {
                 DfgVarArray* const vtxp = new DfgVarArray{*m_dfgp, varp};
@@ -122,7 +122,7 @@ class AstToDfgVisitor final : public VNVisitor {
                 varp->user1p(vtxp);
             }
         }
-        return varp->user1u().to<DfgVertexLValue*>();
+        return varp->user1u().to<DfgVertexVar*>();
     }
 
     DfgVertex* getVertex(AstNode* nodep) {
diff --git a/src/V3DfgDfgToAst.cpp b/src/V3DfgDfgToAst.cpp
index 9666b203c..de08f1060 100644
--- a/src/V3DfgDfgToAst.cpp
+++ b/src/V3DfgDfgToAst.cpp
@@ -42,8 +42,8 @@ namespace {
 
 // Create an AstNodeMath out of a DfgVertex. For most AstNodeMath subtypes, this can be done
 // automatically. For the few special cases, we provide specializations below
-template <typename Node, typename... Ops>
-Node* makeNode(const DfgForAst<Node>* vtxp, Ops... ops) {
+template <typename Node, typename Vertex, typename... Ops>
+Node* makeNode(const Vertex* vtxp, Ops... ops) {
     Node* const nodep = new Node{vtxp->fileline(), ops...};
     UASSERT_OBJ(nodep->width() == static_cast<int>(vtxp->width()), vtxp,
                 "Incorrect width in AstNode created from DfgVertex "
@@ -55,31 +55,31 @@ Node* makeNode(const DfgForAst<Node>* vtxp, Ops... ops) {
 // Vertices needing special conversion
 
 template <>
-AstExtend* makeNode<AstExtend, AstNodeMath*>(  //
+AstExtend* makeNode<AstExtend, DfgExtend, AstNodeMath*>(  //
     const DfgExtend* vtxp, AstNodeMath* op1) {
     return new AstExtend{vtxp->fileline(), op1, static_cast<int>(vtxp->width())};
 }
 
 template <>
-AstExtendS* makeNode<AstExtendS, AstNodeMath*>(  //
+AstExtendS* makeNode<AstExtendS, DfgExtendS, AstNodeMath*>(  //
     const DfgExtendS* vtxp, AstNodeMath* op1) {
     return new AstExtendS{vtxp->fileline(), op1, static_cast<int>(vtxp->width())};
 }
 
 template <>
-AstShiftL* makeNode<AstShiftL, AstNodeMath*, AstNodeMath*>(  //
+AstShiftL* makeNode<AstShiftL, DfgShiftL, AstNodeMath*, AstNodeMath*>(  //
     const DfgShiftL* vtxp, AstNodeMath* op1, AstNodeMath* op2) {
     return new AstShiftL{vtxp->fileline(), op1, op2, static_cast<int>(vtxp->width())};
 }
 
 template <>
-AstShiftR* makeNode<AstShiftR, AstNodeMath*, AstNodeMath*>(  //
+AstShiftR* makeNode<AstShiftR, DfgShiftR, AstNodeMath*, AstNodeMath*>(  //
     const DfgShiftR* vtxp, AstNodeMath* op1, AstNodeMath* op2) {
     return new AstShiftR{vtxp->fileline(), op1, op2, static_cast<int>(vtxp->width())};
 }
 
 template <>
-AstShiftRS* makeNode<AstShiftRS, AstNodeMath*, AstNodeMath*>(  //
+AstShiftRS* makeNode<AstShiftRS, DfgShiftRS, AstNodeMath*, AstNodeMath*>(  //
     const DfgShiftRS* vtxp, AstNodeMath* op1, AstNodeMath* op2) {
     return new AstShiftRS{vtxp->fileline(), op1, op2, static_cast<int>(vtxp->width())};
 }
@@ -88,20 +88,21 @@ AstShiftRS* makeNode<AstShiftRS, AstNodeMath*, AstNodeMath*>(  //
 // Currently unhandled nodes - see corresponding AstToDfg functions
 // LCOV_EXCL_START
 template <>
-AstCCast* makeNode<AstCCast, AstNodeMath*>(const DfgCCast* vtxp, AstNodeMath*) {
+AstCCast* makeNode<AstCCast, DfgCCast, AstNodeMath*>(const DfgCCast* vtxp, AstNodeMath*) {
     vtxp->v3fatalSrc("not implemented");
 }
 template <>
-AstAtoN* makeNode<AstAtoN, AstNodeMath*>(const DfgAtoN* vtxp, AstNodeMath*) {
+AstAtoN* makeNode<AstAtoN, DfgAtoN, AstNodeMath*>(const DfgAtoN* vtxp, AstNodeMath*) {
     vtxp->v3fatalSrc("not implemented");
 }
 template <>
-AstCompareNN* makeNode<AstCompareNN, AstNodeMath*, AstNodeMath*>(const DfgCompareNN* vtxp,
+AstCompareNN*
+makeNode<AstCompareNN, DfgCompareNN, AstNodeMath*, AstNodeMath*>(const DfgCompareNN* vtxp,
                                                                  AstNodeMath*, AstNodeMath*) {
     vtxp->v3fatalSrc("not implemented");
 }
 template <>
-AstSliceSel* makeNode<AstSliceSel, AstNodeMath*, AstNodeMath*, AstNodeMath*>(
+AstSliceSel* makeNode<AstSliceSel, DfgSliceSel, AstNodeMath*, AstNodeMath*, AstNodeMath*>(
     const DfgSliceSel* vtxp, AstNodeMath*, AstNodeMath*, AstNodeMath*) {
     vtxp->v3fatalSrc("not implemented");
 }
@@ -215,8 +216,7 @@ class DfgToAstVisitor final : DfgVisitor {
         // Inline vertices that drive only a single node, or are special
         if (!vtx.hasMultipleSinks()) return true;
         if (vtx.is<DfgConst>()) return true;
-        if (vtx.is<DfgVarPacked>()) return true;
-        if (vtx.is<DfgVarArray>()) return true;
+        if (vtx.is<DfgVertexVar>()) return true;
         if (const DfgArraySel* const selp = vtx.cast<DfgArraySel>()) {
             return selp->bitp()->is<DfgConst>();
         }
diff --git a/src/V3DfgPasses.cpp b/src/V3DfgPasses.cpp
index 0c975fa98..bd192416a 100644
--- a/src/V3DfgPasses.cpp
+++ b/src/V3DfgPasses.cpp
@@ -154,7 +154,7 @@ void V3DfgPasses::removeVars(DfgGraph& dfg, DfgRemoveVarsContext& ctx) {
 void V3DfgPasses::removeUnused(DfgGraph& dfg) {
     const auto processVertex = [&](DfgVertex& vtx) {
         // Keep variables
-        if (vtx.is<DfgVarPacked>() || vtx.is<DfgVarArray>()) return false;
+        if (vtx.is<DfgVertexVar>()) return false;
         // Keep if it has sinks
         if (vtx.hasSinks()) return false;
         // Unlink and delete vertex
diff --git a/src/V3DfgPeephole.cpp b/src/V3DfgPeephole.cpp
index 8ba02b5e2..e02671d64 100644
--- a/src/V3DfgPeephole.cpp
+++ b/src/V3DfgPeephole.cpp
@@ -115,7 +115,7 @@ class V3DfgPeephole final : public DfgVisitor {
     DfgConst* makeZero(FileLine* flp, uint32_t width) { return makeConst(flp, width, 0); }
 
     // Transformations that apply to all commutative binary vertices
-    void commutativeBinary(DfgVertexWithArity<2>* vtxp) {
+    void commutativeBinary(DfgVertexBinary* vtxp) {
         DfgVertex* const lhsp = vtxp->source<0>();
         DfgVertex* const rhsp = vtxp->source<1>();
         // Ensure Const is on left-hand side to simplify other patterns
@@ -138,9 +138,9 @@ class V3DfgPeephole final : public DfgVisitor {
         }
         // If both sides are variable references, order the side in some defined way. This allows
         // CSE to later merge 'a op b' with 'b op a'.
-        if (lhsp->is<DfgVarPacked>() && rhsp->is<DfgVarPacked>()) {
-            AstVar* const lVarp = lhsp->as<DfgVarPacked>()->varp();
-            AstVar* const rVarp = rhsp->as<DfgVarPacked>()->varp();
+        if (lhsp->is<DfgVertexVar>() && rhsp->is<DfgVertexVar>()) {
+            AstVar* const lVarp = lhsp->as<DfgVertexVar>()->varp();
+            AstVar* const rVarp = rhsp->as<DfgVertexVar>()->varp();
             if (lVarp->name() > rVarp->name()) {
                 APPLYING(SWAP_VAR_IN_COMMUTATIVE_BINARY) {
                     vtxp->lhsp(rhsp);
@@ -152,12 +152,12 @@ class V3DfgPeephole final : public DfgVisitor {
     }
 
     // Transformations that apply to all associative binary vertices
-    void associativeBinary(DfgVertexWithArity<2>* vtxp) {
+    void associativeBinary(DfgVertexBinary* vtxp) {
         DfgVertex* const lhsp = vtxp->lhsp();
 
         // Make associative trees right leaning (for better CSE opportunities)
         if (lhsp->type() == vtxp->type() && !lhsp->hasMultipleSinks()) {
-            DfgVertexWithArity<2>* const lBinp = static_cast<DfgVertexWithArity<2>*>(lhsp);
+            DfgVertexBinary* const lBinp = lhsp->as<DfgVertexBinary>();
             APPLYING(RIGHT_LEANING_ASSOC) {
                 vtxp->replaceWith(lBinp);
                 vtxp->lhsp(lBinp->rhsp());
@@ -242,7 +242,7 @@ class V3DfgPeephole final : public DfgVisitor {
                 newRhsp->rhsp(concatp->rhsp());
 
                 // The replacement Vertex
-                DfgVertexWithArity<2>* const replacementp
+                DfgVertexBinary* const replacementp
                     = std::is_same<Vertex, DfgEq>::value
                           ? new DfgAnd{m_dfg, concatp->fileline(), m_bitDType}
                           : nullptr;
@@ -334,7 +334,7 @@ class V3DfgPeephole final : public DfgVisitor {
                 rReducep->srcp(concatp->rhsp());
 
                 // Bitwise reduce the results
-                DfgVertexWithArity<2>* const replacementp = new Bitwise{m_dfg, flp, m_bitDType};
+                Bitwise* const replacementp = new Bitwise{m_dfg, flp, m_bitDType};
                 replacementp->lhsp(lReducep);
                 replacementp->rhsp(rReducep);
                 vtxp->replaceWith(replacementp);
@@ -362,7 +362,7 @@ class V3DfgPeephole final : public DfgVisitor {
         }
     }
 
-    void optimizeShiftRHS(DfgVertexWithArity<2>* vtxp) {
+    void optimizeShiftRHS(DfgVertexBinary* vtxp) {
         if (const DfgConcat* const concatp = vtxp->rhsp()->cast<DfgConcat>()) {
             if (concatp->lhsp()->isZero()) {  // Drop redundant zero extension
                 APPLYING(REMOVE_REDUNDANT_ZEXT_ON_RHS_OF_SHIFT) {  //
@@ -1330,12 +1330,12 @@ class V3DfgPeephole final : public DfgVisitor {
 
     // Process one vertex. Return true if graph changed
     bool processVertex(DfgVertex& vtx) {
-        // Keep DfgVertexLValue vertices in this pass. We will remove them later if they become
+        // Keep DfgVertexVar vertices in this pass. We will remove them later if they become
         // redundant. We want to keep the original variables for non-var vertices that drive
         // multiple sinks (otherwise we would need to introduce a temporary, but it is better for
         // debugging to keep the original variable name, if one is available), so we can't remove
         // redundant variables here.
-        const bool keep = vtx.is<DfgVarPacked>() || vtx.is<DfgVarArray>();
+        const bool keep = vtx.is<DfgVertexVar>();
 
         // If it has no sinks (unused), we can remove it
         if (!keep && !vtx.hasSinks()) {
diff --git a/src/V3DfgVertices.h b/src/V3DfgVertices.h
new file mode 100644
index 000000000..f504bcbd3
--- /dev/null
+++ b/src/V3DfgVertices.h
@@ -0,0 +1,229 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: DfgVertex sub-classes
+//
+// Code available from: https://verilator.org
+//
+//*************************************************************************
+//
+// Copyright 2003-2022 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+//
+//*************************************************************************
+//
+// This is a data-flow graph based representation of combinational logic,
+// the main difference from a V3Graph is that DfgVertex owns the storage
+// of it's input edges (operands/sources/arguments), and can access each
+// input edge directly by indexing, making modifications more efficient
+// than the linked list based structures used by V3Graph.
+//
+// A bulk of the DfgVertex sub-types are generated by astgen, and are
+// analogous to the corresponding AstNode sub-types.
+//
+// See also the internals documentation docs/internals.rst
+//
+//*************************************************************************
+
+#ifndef VERILATOR_V3DFGVERTICES_H_
+#define VERILATOR_V3DFGVERTICES_H_
+
+#ifndef VERILATOR_V3DFG_H_
+#error "Use V3Dfg.h as the include"
+#include "V3Dfg.h"  // This helps code analysis tools pick up symbols in V3Dfg.h
+#define VL_NOT_FINAL  // This #define fixes broken code folding in the CLion IDE
+#endif
+
+// === Abstract base node types (DfgVertex*) ===================================
+
+class DfgVertexVar VL_NOT_FINAL : public DfgVertexVariadic {
+    AstVar* const m_varp;  // The AstVar associated with this vertex (not owned by this vertex)
+    bool m_hasModRefs = false;  // This AstVar is referenced outside the DFG, but in the module
+    bool m_hasExtRefs = false;  // This AstVar is referenced from outside the module
+
+public:
+    DfgVertexVar(DfgGraph& dfg, VDfgType type, AstVar* varp, uint32_t initialCapacity)
+        : DfgVertexVariadic{dfg, type, varp->fileline(), dtypeFor(varp), initialCapacity}
+        , m_varp{varp} {}
+    ASTGEN_MEMBERS_DfgVertexVar;
+
+    AstVar* varp() const { return m_varp; }
+    bool hasModRefs() const { return m_hasModRefs; }
+    void setHasModRefs() { m_hasModRefs = true; }
+    bool hasExtRefs() const { return m_hasExtRefs; }
+    void setHasExtRefs() { m_hasExtRefs = true; }
+    bool hasRefs() const { return m_hasModRefs || m_hasExtRefs; }
+
+    // Variable cannot be removed, even if redundant in the DfgGraph (might be used externally)
+    bool keep() const {
+        // Keep if referenced outside this module
+        if (hasExtRefs()) return true;
+        // Keep if traced
+        if (v3Global.opt.trace() && varp()->isTrace()) return true;
+        // Keep if public
+        if (varp()->isSigPublic()) return true;
+        // Otherwise it can be removed
+        return false;
+    }
+};
+
+// === Concrete node types =====================================================
+
+// === DfgVertex ===
+class DfgConst final : public DfgVertex {
+    friend class DfgVertex;
+    friend class DfgVisitor;
+
+    AstConst* const m_constp;  // The AstConst associated with this vertex (owned by this vertex)
+
+    bool selfEquals(const DfgVertex& that) const override;
+    V3Hash selfHash() const override;
+
+public:
+    DfgConst(DfgGraph& dfg, AstConst* constp)
+        : DfgVertex{dfg, dfgType(), constp->fileline(), dtypeFor(constp)}
+        , m_constp{constp} {}
+    ASTGEN_MEMBERS_DfgConst;
+
+    ~DfgConst() override { VL_DO_DANGLING(m_constp->deleteTree(), m_constp); }
+
+    AstConst* constp() const { return m_constp; }
+    V3Number& num() const { return m_constp->num(); }
+
+    uint32_t toU32() const { return num().toUInt(); }
+    int32_t toI32() const { return num().toSInt(); }
+
+    bool isZero() const { return num().isEqZero(); }
+    bool isOnes() const { return num().isEqAllOnes(width()); }
+
+    std::pair<DfgEdge*, size_t> sourceEdges() override { return {nullptr, 0}; }
+    std::pair<const DfgEdge*, size_t> sourceEdges() const override { return {nullptr, 0}; }
+    const string srcName(size_t) const override {  // LCOV_EXCL_START
+        VL_UNREACHABLE;
+        return "";
+    }  // LCOV_EXCL_STOP
+};
+
+// === DfgVertexVar ===
+class DfgVarArray final : public DfgVertexVar {
+    friend class DfgVertex;
+    friend class DfgVisitor;
+
+    using DriverData = std::pair<FileLine*, uint32_t>;
+
+    std::vector<DriverData> m_driverData;  // Additional data associate with each driver
+
+    bool selfEquals(const DfgVertex& that) const override;
+    V3Hash selfHash() const override;
+
+public:
+    DfgVarArray(DfgGraph& dfg, AstVar* varp)
+        : DfgVertexVar{dfg, dfgType(), varp, 4u} {
+        UASSERT_OBJ(VN_IS(varp->dtypeSkipRefp(), UnpackArrayDType), varp, "Non array DfgVarArray");
+    }
+    ASTGEN_MEMBERS_DfgVarArray;
+
+    bool isDrivenByDfg() const { return arity() > 0; }
+
+    void addDriver(FileLine* flp, uint32_t index, DfgVertex* vtxp) {
+        m_driverData.emplace_back(flp, index);
+        DfgVertexVariadic::addSource()->relinkSource(vtxp);
+    }
+
+    void resetSources() {
+        m_driverData.clear();
+        DfgVertexVariadic::resetSources();
+    }
+
+    // Remove undriven sources
+    void packSources() {
+        // Grab and reset the driver data
+        std::vector<DriverData> driverData{std::move(m_driverData)};
+
+        // Grab and unlink the sources
+        std::vector<DfgVertex*> sources{arity()};
+        forEachSourceEdge([&](DfgEdge& edge, size_t idx) {
+            sources[idx] = edge.sourcep();
+            edge.unlinkSource();
+        });
+        DfgVertexVariadic::resetSources();
+
+        // Add back the driven sources
+        for (size_t i = 0; i < sources.size(); ++i) {
+            if (!sources[i]) continue;
+            addDriver(driverData[i].first, driverData[i].second, sources[i]);
+        }
+    }
+
+    FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; }
+    uint32_t driverIndex(size_t idx) const { return m_driverData[idx].second; }
+
+    DfgVertex* driverAt(size_t idx) const {
+        const DfgEdge* const edgep = findSourceEdge([=](const DfgEdge&, size_t i) {  //
+            return driverIndex(i) == idx;
+        });
+        return edgep ? edgep->sourcep() : nullptr;
+    }
+
+    const string srcName(size_t idx) const override { return cvtToStr(driverIndex(idx)); }
+};
+class DfgVarPacked final : public DfgVertexVar {
+    friend class DfgVertex;
+    friend class DfgVisitor;
+
+    using DriverData = std::pair<FileLine*, uint32_t>;
+
+    std::vector<DriverData> m_driverData;  // Additional data associate with each driver
+
+    bool selfEquals(const DfgVertex& that) const override;
+    V3Hash selfHash() const override;
+
+public:
+    DfgVarPacked(DfgGraph& dfg, AstVar* varp)
+        : DfgVertexVar{dfg, dfgType(), varp, 1u} {}
+    ASTGEN_MEMBERS_DfgVarPacked;
+
+    bool isDrivenByDfg() const { return arity() > 0; }
+    bool isDrivenFullyByDfg() const { return arity() == 1 && source(0)->dtypep() == dtypep(); }
+
+    void addDriver(FileLine* flp, uint32_t lsb, DfgVertex* vtxp) {
+        m_driverData.emplace_back(flp, lsb);
+        DfgVertexVariadic::addSource()->relinkSource(vtxp);
+    }
+
+    void resetSources() {
+        m_driverData.clear();
+        DfgVertexVariadic::resetSources();
+    }
+
+    // Remove undriven sources
+    void packSources() {
+        // Grab and reset the driver data
+        std::vector<DriverData> driverData{std::move(m_driverData)};
+
+        // Grab and unlink the sources
+        std::vector<DfgVertex*> sources{arity()};
+        forEachSourceEdge([&](DfgEdge& edge, size_t idx) {
+            sources[idx] = edge.sourcep();
+            edge.unlinkSource();
+        });
+        DfgVertexVariadic::resetSources();
+
+        // Add back the driven sources
+        for (size_t i = 0; i < sources.size(); ++i) {
+            if (!sources[i]) continue;
+            addDriver(driverData[i].first, driverData[i].second, sources[i]);
+        }
+    }
+
+    FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; }
+    uint32_t driverLsb(size_t idx) const { return m_driverData[idx].second; }
+
+    const string srcName(size_t idx) const override {
+        return isDrivenFullyByDfg() ? "" : cvtToStr(driverLsb(idx));
+    }
+};
+
+#endif
diff --git a/src/astgen b/src/astgen
index f0883dd08..3348d0e44 100755
--- a/src/astgen
+++ b/src/astgen
@@ -8,12 +8,14 @@ import os
 import re
 import sys
 import textwrap
+
 # from pprint import pprint, pformat
 
 
+# This class is used to represents both AstNode and DfgVertex sub-types
 class Node:
 
-    def __init__(self, name, superClass, file, lineno):
+    def __init__(self, name, superClass, file=None, lineno=None):
         self._name = name
         self._superClass = superClass
         self._subClasses = []  # Initially list, but tuple after completion
@@ -173,9 +175,11 @@ class Node:
         return self in other.allSubClasses
 
 
-Nodes = {}
-SortedNodes = None
-DfgVertices = None
+AstNodes = {}
+AstNodeList = None
+
+DfgVertices = {}
+DfgVertexList = None
 
 ClassRefs = {}
 Stages = {}
@@ -278,7 +282,7 @@ class Cpt:
                 self.error("Can't parse from function: " + func)
             typen = match.group(1)
             subnodes = match.group(2)
-            if Nodes[typen].isRoot:
+            if AstNodes[typen].isRoot:
                 self.error("Unknown AstNode typen: " + typen + ": in " + func)
 
             mif = ""
@@ -333,7 +337,7 @@ class Cpt:
         elif match_skip:
             typen = match_skip.group(1)
             self.tree_skip_visit[typen] = 1
-            if typen not in Nodes:
+            if typen not in AstNodes:
                 self.error("Unknown node type: " + typen)
 
         else:
@@ -463,7 +467,7 @@ class Cpt:
         self.print(
             "    // Bottom class up, as more simple transforms are generally better\n"
         )
-        for node in SortedNodes:
+        for node in AstNodeList:
             out_for_type_sc = []
             out_for_type = []
             classes = list(node.allSuperClasses)
@@ -502,7 +506,7 @@ class Cpt:
                     "".join(out_for_type_sc))
                 if out_for_type[0]:
                     self.print("      iterateAndNextNull(nodep->rhsp());\n")
-                    if node.isSubClassOf(Nodes["NodeTriop"]):
+                    if node.isSubClassOf(AstNodes["NodeTriop"]):
                         self.print(
                             "      iterateAndNextNull(nodep->thsp());\n")
                     self.print("".join(out_for_type) + "    }\n")
@@ -542,7 +546,7 @@ def parseOpType(string):
     return None
 
 
-def read_types(filename):
+def read_types(filename, Nodes, prefix):
     hasErrors = False
 
     def error(lineno, message):
@@ -560,8 +564,9 @@ def read_types(filename):
             return
         if not hasAstgenMembers:
             error(
-                node.lineno, "'Ast" + node.name +
-                "' does not contain 'ASTGEN_MEMBERS_" + node.name + ";'")
+                node.lineno,
+                "'{p}{n}' does not contain 'ASTGEN_MEMBERS_{p}{n};'".format(
+                    p=prefix, n=node.name))
         hasAstgenMembers = False
 
     with open(filename) as fh:
@@ -575,12 +580,12 @@ def read_types(filename):
                 classn = match.group(2)
                 match = re.search(r':\s*public\s+(\S+)', line)
                 supern = match.group(1) if match else ""
-                if re.search(r'Ast', supern):
-                    classn = re.sub(r'^Ast', '', classn)
-                    supern = re.sub(r'^Ast', '', supern)
+                if re.search(prefix, supern):
+                    classn = re.sub(r'^' + prefix, '', classn)
+                    supern = re.sub(r'^' + prefix, '', supern)
                     if not supern:
-                        sys.exit("%Error: 'Ast{}' has no super-class".format(
-                            classn))
+                        sys.exit("%Error: '{p}{c}' has no super-class".format(
+                            p=prefix, c=classn))
                     checkFinishedNode(node)
                     superClass = Nodes[supern]
                     node = Node(classn, superClass, filename, lineno)
@@ -589,8 +594,13 @@ def read_types(filename):
             if not node:
                 continue
 
-            if re.match(r'^\s*ASTGEN_MEMBERS_' + node.name + ';', line):
+            if re.match(r'^\s*ASTGEN_MEMBERS_' + prefix + node.name + ';',
+                        line):
                 hasAstgenMembers = True
+
+            if prefix != "Ast":
+                continue
+
             match = re.match(r'^\s*//\s*@astgen\s+(.*)$', line)
             if match:
                 decl = re.sub(r'//.*$', '', match.group(1))
@@ -650,6 +660,59 @@ def read_types(filename):
         sys.exit("%Error: Stopping due to errors reported above")
 
 
+def check_types(sortedTypes, prefix, abstractPrefix):
+    baseClass = prefix + abstractPrefix
+
+    # Check all leaf types are not AstNode* and non-leaves are AstNode*
+    for node in sortedTypes:
+        if re.match(r'^' + abstractPrefix, node.name):
+            if node.isLeaf:
+                sys.exit(
+                    "%Error: Final {b} subclasses must not be named {b}*: {p}{n}"
+                    .format(b=baseClass, p=prefix, n=node.name))
+        else:
+            if not node.isLeaf:
+                sys.exit(
+                    "%Error: Non-final {b} subclasses must be named {b}*: {p}{n}"
+                    .format(b=baseClass, p=prefix, n=node.name))
+
+    # Check ordering of node definitions
+    hasOrderingError = False
+
+    files = tuple(
+        sorted(set(_.file for _ in sortedTypes if _.file is not None)))
+
+    for file in files:
+        nodes = tuple(filter(lambda _, f=file: _.file == f, sortedTypes))
+        expectOrder = tuple(sorted(nodes, key=lambda _: (_.isLeaf, _.ordIdx)))
+        actualOrder = tuple(sorted(nodes, key=lambda _: _.lineno))
+        expect = {
+            node: pred
+            for pred, node in zip((None, ) + expectOrder[:-1], expectOrder)
+        }
+        actual = {
+            node: pred
+            for pred, node in zip((None, ) + actualOrder[:-1], actualOrder)
+        }
+        for node in nodes:
+            if expect[node] != actual[node]:
+                hasOrderingError = True
+                pred = expect[node]
+                print(
+                    "{file}:{lineno}: %Error: Definition of '{p}{n}' is out of order. Shold be {where}."
+                    .format(file=file,
+                            lineno=node.lineno,
+                            p=prefix,
+                            n=node.name,
+                            where=("right after '" + prefix + pred.name +
+                                   "'" if pred else "first in file")),
+                    file=sys.stderr)
+
+    if hasOrderingError:
+        sys.exit(
+            "%Error: Stopping due to out of order definitions listed above")
+
+
 def read_stages(filename):
     with open(filename) as fh:
         n = 100
@@ -712,7 +775,7 @@ def write_report(filename):
             fh.write("  " + classn + "\n")
 
         fh.write("\nClasses:\n")
-        for node in SortedNodes:
+        for node in AstNodeList:
             fh.write("  class Ast%-17s\n" % node.name)
             fh.write("    arity:  {}\n".format(node.arity))
             fh.write("    parent: ")
@@ -741,97 +804,110 @@ def write_report(filename):
             fh.write("\n")
 
 
-def write_classes(filename):
-    with open_file(filename) as fh:
-        fh.write("class AstNode;\n")
-        for node in SortedNodes:
-            fh.write("class Ast%-17s // " % (node.name + ";"))
+################################################################################
+# Common code genaration
+################################################################################
+
+
+def write_forward_class_decls(prefix, nodeList):
+    with open_file("V3{p}__gen_forward_class_decls.h".format(p=prefix)) as fh:
+        for node in nodeList:
+            fh.write("class {p}{n:<17} // ".format(p=prefix,
+                                                   n=node.name + ";"))
             for superClass in node.allSuperClasses:
-                fh.write("Ast%-12s " % superClass.name)
+                fh.write("{p}{n:<12} ".format(p=prefix, n=superClass.name))
             fh.write("\n")
 
 
-def write_visitor_decls(filename):
-    with open_file(filename) as fh:
-        for node in SortedNodes:
+def write_visitor_decls(prefix, nodeList):
+    with open_file("V3{p}__gen_visitor_decls.h".format(p=prefix)) as fh:
+        for node in nodeList:
             if not node.isRoot:
-                fh.write("virtual void visit(Ast" + node.name + "*);\n")
+                fh.write("virtual void visit({p}{n}*);\n".format(p=prefix,
+                                                                 n=node.name))
 
 
-def write_visitor_defns(filename):
-    with open_file(filename) as fh:
-        for node in SortedNodes:
+def write_visitor_defns(prefix, nodeList, visitor):
+    with open_file("V3{p}__gen_visitor_defns.h".format(p=prefix)) as fh:
+        variable = "nodep" if prefix == "Ast" else "vtxp"
+        for node in nodeList:
             base = node.superClass
             if base is not None:
-                fh.write("void VNVisitor::visit(Ast" + node.name +
-                         "* nodep) { visit(static_cast<Ast" + base.name +
-                         "*>(nodep)); }\n")
+                fh.write(
+                    "void {c}::visit({p}{n}* {v}) {{ visit(static_cast<{p}{b}*>({v})); }}\n"
+                    .format(c=visitor,
+                            p=prefix,
+                            n=node.name,
+                            b=base.name,
+                            v=variable))
 
 
-def write_impl(filename):
-    with open_file(filename) as fh:
-        fh.write("\n")
-        fh.write("// For internal use. They assume argument is not nullptr.\n")
-        for node in SortedNodes:
-            fh.write("template<> inline bool AstNode::privateTypeTest<Ast" +
-                     node.name + ">(const AstNode* nodep) { ")
-            if node.isRoot:
-                fh.write("return true; ")
-            else:
-                fh.write("return ")
-                if not node.isLeaf:
-                    fh.write(
-                        "static_cast<int>(nodep->type()) >= static_cast<int>(VNType::first"
-                        + node.name + ") && ")
-                    fh.write(
-                        "static_cast<int>(nodep->type()) <= static_cast<int>(VNType::last"
-                        + node.name + "); ")
-                else:
-                    fh.write("nodep->type() == VNType::at" + node.name + "; ")
-            fh.write("}\n")
+def write_type_enum(prefix, nodeList):
+    root = next(_ for _ in nodeList if _.isRoot)
+    with open_file("V3{p}__gen_type_enum.h".format(p=prefix)) as fh:
 
-
-def write_types(filename):
-    with open_file(filename) as fh:
         fh.write("    enum en : uint16_t {\n")
-        for node in sorted(filter(lambda _: _.isLeaf, SortedNodes),
+        for node in sorted(filter(lambda _: _.isLeaf, nodeList),
                            key=lambda _: _.typeId):
-            fh.write("        at" + node.name + " = " + str(node.typeId) +
-                     ",\n")
-        fh.write("        _ENUM_END = " + str(Nodes["Node"].typeIdMax + 1) +
-                 "\n")
+            fh.write("        at{t} = {n},\n".format(t=node.name,
+                                                     n=node.typeId))
+        fh.write("        _ENUM_END = {n}\n".format(n=root.typeIdMax + 1))
         fh.write("    };\n")
 
         fh.write("    enum bounds : uint16_t {\n")
-        for node in sorted(filter(lambda _: not _.isLeaf, SortedNodes),
+        for node in sorted(filter(lambda _: not _.isLeaf, nodeList),
                            key=lambda _: _.typeIdMin):
-            fh.write("        first" + node.name + " = " +
-                     str(node.typeIdMin) + ",\n")
-            fh.write("        last" + node.name + " = " + str(node.typeIdMax) +
-                     ",\n")
+            fh.write("        first{t} = {n},\n".format(t=node.name,
+                                                        n=node.typeIdMin))
+            fh.write("        last{t}  = {n},\n".format(t=node.name,
+                                                        n=node.typeIdMax))
         fh.write("        _BOUNDS_END\n")
         fh.write("    };\n")
 
         fh.write("    const char* ascii() const {\n")
         fh.write("        static const char* const names[_ENUM_END + 1] = {\n")
-        for node in sorted(filter(lambda _: _.isLeaf, SortedNodes),
+        for node in sorted(filter(lambda _: _.isLeaf, nodeList),
                            key=lambda _: _.typeId):
-            fh.write("            \"" + node.name.upper() + "\",\n")
+            fh.write('            "{T}",\n'.format(T=node.name.upper()))
         fh.write("            \"_ENUM_END\"\n")
         fh.write("        };\n")
         fh.write("        return names[m_e];\n")
         fh.write("    }\n")
 
 
-def write_yystype(filename):
-    with open_file(filename) as fh:
-        for node in SortedNodes:
-            fh.write("Ast{t}* {m}p;\n".format(t=node.name,
-                                              m=node.name[0].lower() +
-                                              node.name[1:]))
+def write_type_tests(prefix, nodeList):
+    with open_file("V3{p}__gen_type_tests.h".format(p=prefix)) as fh:
+        fh.write("// For internal use. They assume argument is not nullptr.\n")
+        if prefix == "Ast":
+            base = "AstNode"
+            variable = "nodep"
+            enum = "VNType"
+        elif prefix == "Dfg":
+            base = "DfgVertex"
+            variable = "vtxp"
+            enum = "VDfgType"
+        for node in nodeList:
+            fh.write(
+                "template<> inline bool {b}::privateTypeTest<{p}{n}>(const {b}* {v}) {{ "
+                .format(b=base, p=prefix, n=node.name, v=variable))
+            if node.isRoot:
+                fh.write("return true;")
+            elif not node.isLeaf:
+                fh.write(
+                    "return static_cast<int>({v}->type()) >= static_cast<int>({e}::first{t}) && static_cast<int>({v}->type()) <= static_cast<int>({e}::last{t});"
+                    .format(v=variable, e=enum, t=node.name))
+            else:
+                fh.write("return {v}->type() == {e}::at{t};".format(
+                    v=variable, e=enum, t=node.name))
+            fh.write(" }\n")
 
 
-def write_macros(filename):
+################################################################################
+# Ast code genaration
+################################################################################
+
+
+def write_ast_macros(filename):
     with open_file(filename) as fh:
 
         def emitBlock(pattern, **fmt):
@@ -839,8 +915,8 @@ def write_macros(filename):
                 textwrap.indent(textwrap.dedent(pattern),
                                 "    ").format(**fmt).replace("\n", " \\\n"))
 
-        for node in SortedNodes:
-            fh.write("#define ASTGEN_MEMBERS_{t} \\\n".format(t=node.name))
+        for node in AstNodeList:
+            fh.write("#define ASTGEN_MEMBERS_Ast{t} \\\n".format(t=node.name))
             emitBlock('''\
             static Ast{t}* cloneTreeNull(Ast{t}* nodep, bool cloneNextLink) {{
                 return nodep ? nodep->cloneTree(cloneNextLink) : nullptr;
@@ -860,7 +936,7 @@ def write_macros(filename):
                 ''',
                           t=node.name)
 
-            for n in (1, 2, 3, 4):
+            for n in range(1, 5):
                 op = node.getOp(n)
                 if not op:
                     continue
@@ -907,7 +983,15 @@ def write_macros(filename):
             fh.write("\n")
 
 
-def write_op_checks(filename):
+def write_ast_yystype(filename):
+    with open_file(filename) as fh:
+        for node in AstNodeList:
+            fh.write("Ast{t}* {m}p;\n".format(t=node.name,
+                                              m=node.name[0].lower() +
+                                              node.name[1:]))
+
+
+def write_ast_op_checks(filename):
     with open_file(filename) as fh:
 
         indent = ""
@@ -917,7 +1001,7 @@ def write_op_checks(filename):
                 textwrap.indent(textwrap.dedent(pattern),
                                 indent).format(**fmt))
 
-        for node in SortedNodes:
+        for node in AstNodeList:
             if not node.isLeaf:
                 continue
 
@@ -991,102 +1075,98 @@ def write_op_checks(filename):
                 ''')
 
 
-def write_dfg_vertex_classes(filename):
+################################################################################
+# DFG code genaration
+################################################################################
+
+
+def write_dfg_macros(filename):
     with open_file(filename) as fh:
-        fh.write("\n")
-        for node in DfgVertices:
-            fh.write("class Dfg{} final : public DfgVertexWithArity<{}> {{\n".
-                     format(node.name, node.arity))
-            fh.write("    friend class DfgVertex;\n")
-            fh.write("    friend class DfgVisitor;\n")
-            fh.write("    void accept(DfgVisitor& visitor) override;\n")
+
+        def emitBlock(pattern, **fmt):
             fh.write(
-                "    static constexpr DfgType dfgType() {{ return DfgType::at{t}; }};\n"
-                .format(t=node.name))
-            fh.write("public:\n")
-            fh.write(
-                "    Dfg{t}(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep) : DfgVertexWithArity<{a}>{{dfg, flp, dtypep, dfgType()}} {{}}\n"
-                .format(t=node.name, a=node.arity))
-            # Accessors
+                textwrap.indent(textwrap.dedent(pattern),
+                                "    ").format(**fmt).replace("\n", " \\\n"))
+
+        for node in DfgVertexList:
+            fh.write("#define ASTGEN_MEMBERS_Dfg{t} \\\n".format(t=node.name))
+
+            if node.isLeaf:
+                emitBlock('''\
+                static constexpr VDfgType dfgType() {{ return VDfgType::at{t}; }};
+                void accept(DfgVisitor& v) override {{ v.visit(this); }}
+                ''',
+                          t=node.name)
+
+            for n in range(1, node.arity + 1):
+                name, _, _ = node.getOp(n)
+                emitBlock('''\
+                DfgVertex* {name}() const {{ return source<{n}>(); }}
+                void {name}(DfgVertex* vtxp) {{ relinkSource<{n}>(vtxp); }}
+                ''',
+                          name=name,
+                          n=n - 1)
+
             operandNames = tuple(
                 node.getOp(n)[0] for n in range(1, node.arity + 1))
-            assert not operandNames or len(operandNames) == node.arity
-            for i, n in enumerate(operandNames):
-                fh.write(
-                    "    DfgVertex* {n}() const {{ return source<{i}>(); }}\n".
-                    format(n=n, i=i))
-            for i, n in enumerate(operandNames):
-                fh.write(
-                    "    void {n}(DfgVertex* vtxp) {{ relinkSource<{i}>(vtxp); }}\n"
-                    .format(n=n, i=i))
             if operandNames:
-                names = ", ".join(map(lambda _: '"' + _ + '"', operandNames))
-                fh.write(
-                    "    const string srcName(size_t idx) const override {\n")
-                fh.write(
-                    "        static const char* names[{a}] = {{ {ns} }};\n".
-                    format(a=node.arity, ns=names))
-                fh.write("        return names[idx];\n")
-                fh.write("    }\n")
-            fh.write("};\n")
-            fh.write("\n")
-        fh.write("\n")
-
-        fh.write("\n\ntemplate<typename Node>\n")
-        fh.write("struct DfgForAstImpl;\n\n")
-        for node in DfgVertices:
-            fh.write("template <>\n")
+                emitBlock('''\
+                          const std::string srcName(size_t idx) const override {{
+                              static const char* names[{a}] = {{ {ns} }};
+                              return names[idx];
+                          }}
+                          ''',
+                          a=node.arity,
+                          ns=", ".join(
+                              map(lambda _: '"' + _ + '"', operandNames)))
             fh.write(
-                "struct DfgForAstImpl<Ast{name}> {{\n".format(name=node.name))
-            fh.write("  using type = Dfg{name};\n".format(name=node.name))
-            fh.write("};\n")
-        fh.write("\ntemplate<typename Node>\n")
-        fh.write("using DfgForAst = typename DfgForAstImpl<Node>::type;\n")
-
-        fh.write("\n\ntemplate<typename Vertex>\n")
-        fh.write("struct AstForDfgImpl;\n\n")
-        for node in DfgVertices:
-            fh.write("template <>\n")
-            fh.write(
-                "struct AstForDfgImpl<Dfg{name}> {{\n".format(name=node.name))
-            fh.write("  using type = Ast{name};\n".format(name=node.name))
-            fh.write("};\n")
-        fh.write("\ntemplate<typename Vertex>\n")
-        fh.write("using AstForDfg = typename AstForDfgImpl<Vertex>::type;\n")
+                "    static_assert(true, \"\")\n")  # Swallowing the semicolon
 
 
-def write_dfg_visitor_decls(filename):
+def write_dfg_auto_classes(filename):
     with open_file(filename) as fh:
-        fh.write("\n")
-        fh.write("virtual void visit(DfgVertex*) = 0;\n")
-        for node in DfgVertices:
-            fh.write("virtual void visit(Dfg{}*);\n".format(node.name))
 
+        def emitBlock(pattern, **fmt):
+            fh.write(textwrap.dedent(pattern).format(**fmt))
 
-def write_dfg_definitions(filename):
-    with open_file(filename) as fh:
+        for node in DfgVertexList:
+            # Only generate code for automatically derieved leaf nodes
+            if (node.file is not None) or not node.isLeaf:
+                continue
+
+            emitBlock('''\
+                      class Dfg{t} final : public Dfg{s} {{
+                      public:
+                          Dfg{t}(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep)
+                              : Dfg{s}{{dfg, dfgType(), flp, dtypep}} {{}}
+                          ASTGEN_MEMBERS_Dfg{t};
+                      }};
+                      ''',
+                      t=node.name,
+                      s=node.superClass.name)
         fh.write("\n")
-        for node in DfgVertices:
-            fh.write(
-                "void Dfg{}::accept(DfgVisitor& visitor) {{ visitor.visit(this); }}\n"
-                .format(node.name))
-        fh.write("\n")
-        for node in DfgVertices:
-            fh.write(
-                "void DfgVisitor::visit(Dfg{}* vtxp) {{ visit(static_cast<DfgVertex*>(vtxp)); }}\n"
-                .format(node.name))
 
 
 def write_dfg_ast_to_dfg(filename):
     with open_file(filename) as fh:
-        fh.write("\n")
-        for node in DfgVertices:
+        for node in DfgVertexList:
+            # Only generate code for automatically derieved leaf nodes
+            if (node.file is not None) or (not node.isLeaf):
+                continue
+
             fh.write(
                 "void visit(Ast{t}* nodep) override {{\n".format(t=node.name))
             fh.write(
-                '    UASSERT_OBJ(!nodep->user1p(), nodep, "Already has Dfg vertex");\n'
+                '    UASSERT_OBJ(!nodep->user1p(), nodep, "Already has Dfg vertex");\n\n'
             )
-            fh.write("    if (unhandled(nodep)) return;\n")
+            fh.write("    if (unhandled(nodep)) return;\n\n")
+            for i in range(node.arity):
+                fh.write("    iterate(nodep->op{j}p());\n".format(j=i + 1))
+                fh.write("    if (m_foundUnhandled) return;\n")
+                fh.write(
+                    '    UASSERT_OBJ(nodep->op{j}p()->user1p(), nodep, "Child {j} missing Dfg vertex");\n'
+                    .format(j=i + 1))
+            fh.write("\n")
             fh.write(
                 "    Dfg{t}* const vtxp = makeVertex<Dfg{t}>(nodep, *m_dfgp);\n"
                 .format(t=node.name))
@@ -1095,24 +1175,23 @@ def write_dfg_ast_to_dfg(filename):
             fh.write("        ++m_ctx.m_nonRepNode;\n")
             fh.write("        return;\n")
             fh.write("    }\n\n")
-            fh.write("    m_uncommittedVertices.push_back(vtxp);\n")
             for i in range(node.arity):
-                fh.write("    iterate(nodep->op{j}p());\n".format(j=i + 1))
-                fh.write("    if (m_foundUnhandled) return;\n")
                 fh.write(
-                    '    UASSERT_OBJ(nodep->op{j}p()->user1p(), nodep, "Child {j} missing Dfg vertex");\n'
-                    .format(j=i + 1))
-                fh.write(
-                    "    vtxp->relinkSource<{i}>(nodep->op{j}p()->user1u().to<DfgVertex*>());\n\n"
+                    "    vtxp->relinkSource<{i}>(nodep->op{j}p()->user1u().to<DfgVertex*>());\n"
                     .format(i=i, j=i + 1))
+            fh.write("\n")
+            fh.write("    m_uncommittedVertices.push_back(vtxp);\n")
             fh.write("    nodep->user1p(vtxp);\n")
             fh.write("}\n")
 
 
 def write_dfg_dfg_to_ast(filename):
     with open_file(filename) as fh:
-        fh.write("\n")
-        for node in DfgVertices:
+        for node in DfgVertexList:
+            # Only generate code for automatically derieved leaf nodes
+            if (node.file is not None) or (not node.isLeaf):
+                continue
+
             fh.write(
                 "void visit(Dfg{t}* vtxp) override {{\n".format(t=node.name))
             for i in range(node.arity):
@@ -1146,6 +1225,9 @@ parser.add_argument('-I', action='store', help='source code include directory')
 parser.add_argument('--astdef',
                     action='append',
                     help='add AST definition file (relative to -I)')
+parser.add_argument('--dfgdef',
+                    action='append',
+                    help='add DFG definition file (relative to -I)')
 parser.add_argument('--classes',
                     action='store_true',
                     help='makes class declaration files')
@@ -1155,66 +1237,86 @@ parser.add_argument('infiles', nargs='*', help='list of input .cpp filenames')
 
 Args = parser.parse_args()
 
+###############################################################################
+# Read AstNode definitions
+###############################################################################
+
 # Set up the root AstNode type. It is standalone so we don't need to parse the
 # sources for this.
-Nodes["Node"] = Node("Node", None, "AstNode", 1)
+AstNodes["Node"] = Node("Node", None)
 
-# Read Ast node definitions
+# Read AstNode definitions
 for filename in Args.astdef:
-    read_types(os.path.join(Args.I, filename))
+    read_types(os.path.join(Args.I, filename), AstNodes, "Ast")
 
 # Compute derived properties over the whole AstNode hierarchy
-Nodes["Node"].complete()
+AstNodes["Node"].complete()
 
-SortedNodes = tuple(map(lambda _: Nodes[_], sorted(Nodes.keys())))
+AstNodeList = tuple(map(lambda _: AstNodes[_], sorted(AstNodes.keys())))
 
-for node in SortedNodes:
-    # Check all leaves are not AstNode* and non-leaves are AstNode*
-    if re.match(r'^Node', node.name):
-        if node.isLeaf:
-            sys.exit(
-                "%Error: Final AstNode subclasses must not be named AstNode*: Ast"
-                + node.name)
+check_types(AstNodeList, "Ast", "Node")
+
+###############################################################################
+# Read and generate DfgVertex definitions
+###############################################################################
+
+# Set up the root DfgVertex type and some other hand-written base types.
+# These are standalone so we don't need to parse the sources for this.
+DfgVertices["Vertex"] = Node("Vertex", None)
+DfgVertices["VertexUnary"] = Node("VertexUnary", DfgVertices["Vertex"])
+DfgVertices["Vertex"].addSubClass(DfgVertices["VertexUnary"])
+DfgVertices["VertexBinary"] = Node("VertexBinary", DfgVertices["Vertex"])
+DfgVertices["Vertex"].addSubClass(DfgVertices["VertexBinary"])
+DfgVertices["VertexTernary"] = Node("VertexTernary", DfgVertices["Vertex"])
+DfgVertices["Vertex"].addSubClass(DfgVertices["VertexTernary"])
+DfgVertices["VertexVariadic"] = Node("VertexVariadic", DfgVertices["Vertex"])
+DfgVertices["Vertex"].addSubClass(DfgVertices["VertexVariadic"])
+
+# Read DfgVertex definitions
+for filename in Args.dfgdef:
+    read_types(os.path.join(Args.I, filename), DfgVertices, "Dfg")
+
+# Add the DfgVertex sub-types automatically derived from AstNode sub-types
+for node in AstNodeList:
+    # Ignore the hierarchy for now
+    if not node.isLeaf:
+        continue
+
+    # Ignore any explicitly defined vertex
+    if node.name in DfgVertices:
+        continue
+
+    if node.isSubClassOf(AstNodes["NodeUniop"]):
+        base = DfgVertices["VertexUnary"]
+    elif node.isSubClassOf(AstNodes["NodeBiop"]):
+        base = DfgVertices["VertexBinary"]
+    elif node.isSubClassOf(AstNodes["NodeTriop"]):
+        base = DfgVertices["VertexTernary"]
     else:
-        if not node.isLeaf:
-            sys.exit(
-                "%Error: Non-final AstNode subclasses must be named AstNode*: Ast"
-                + node.name)
+        continue
 
-DfgBases = (Nodes["NodeUniop"], Nodes["NodeBiop"], Nodes["NodeTriop"])
-DfgVertices = tuple(
-    node for node in SortedNodes
-    if node.isLeaf and any(node.isSubClassOf(base) for base in DfgBases))
+    vertex = Node(node.name, base)
+    DfgVertices[node.name] = vertex
+    base.addSubClass(vertex)
 
-# Check ordering of node definitions
-files = tuple(sorted(set(_.file for _ in SortedNodes)))
+    for n in range(1, node.arity + 1):
+        op = node.getOp(n)
+        if op is not None:
+            name, monad, kind = op
+            assert monad == "", "Cannot represnt AstNode as DfgVertex"
+            vertex.addOp(n, name, "", "")
 
-hasOrderingError = False
-for file in files:
-    nodes = tuple(filter(lambda _, f=file: _.file == f, SortedNodes))
-    expectOrder = tuple(sorted(nodes, key=lambda _: (_.isLeaf, _.ordIdx)))
-    actualOrder = tuple(sorted(nodes, key=lambda _: _.lineno))
-    expect = {
-        node: pred
-        for pred, node in zip((None, ) + expectOrder[:-1], expectOrder)
-    }
-    actual = {
-        node: pred
-        for pred, node in zip((None, ) + actualOrder[:-1], actualOrder)
-    }
-    for node in nodes:
-        if expect[node] != actual[node]:
-            hasOrderingError = True
-            pred = expect[node]
-            print(file + ":" + str(node.lineno) +
-                  ": %Error: Definition of 'Ast" + node.name +
-                  "' is out of order. Should be " +
-                  ("right after 'Ast" + pred.name +
-                   "'" if pred else "first in file") + ".",
-                  file=sys.stderr)
+# Compute derived properties over the whole DfgVertex hierarchy
+DfgVertices["Vertex"].complete()
 
-if hasOrderingError:
-    sys.exit("%Error: Stopping due to out of order definitions listed above")
+DfgVertexList = tuple(map(lambda _: DfgVertices[_],
+                          sorted(DfgVertices.keys())))
+
+check_types(DfgVertexList, "Dfg", "Vertex")
+
+###############################################################################
+# Read additional files
+###############################################################################
 
 read_stages(Args.I + "/Verilator.cpp")
 
@@ -1224,19 +1326,29 @@ source_files.extend(glob.glob(Args.I + "/*.cpp"))
 for filename in source_files:
     read_refs(filename)
 
+###############################################################################
+# Generate output
+###############################################################################
+
 if Args.classes:
     write_report("V3Ast__gen_report.txt")
-    write_classes("V3Ast__gen_classes.h")
-    write_visitor_decls("V3Ast__gen_visitor_decls.h")
-    write_visitor_defns("V3Ast__gen_visitor_defns.h")
-    write_impl("V3Ast__gen_impl.h")
-    write_types("V3Ast__gen_types.h")
-    write_yystype("V3Ast__gen_yystype.h")
-    write_macros("V3Ast__gen_macros.h")
-    write_op_checks("V3Ast__gen_op_checks.h")
-    write_dfg_vertex_classes("V3Dfg__gen_vertex_classes.h")
-    write_dfg_visitor_decls("V3Dfg__gen_visitor_decls.h")
-    write_dfg_definitions("V3Dfg__gen_definitions.h")
+    # Write Ast code
+    write_forward_class_decls("Ast", AstNodeList)
+    write_visitor_decls("Ast", AstNodeList)
+    write_visitor_defns("Ast", AstNodeList, "VNVisitor")
+    write_type_enum("Ast", AstNodeList)
+    write_type_tests("Ast", AstNodeList)
+    write_ast_macros("V3Ast__gen_macros.h")
+    write_ast_yystype("V3Ast__gen_yystype.h")
+    write_ast_op_checks("V3Ast__gen_op_checks.h")
+    # Write Dfg code
+    write_forward_class_decls("Dfg", DfgVertexList)
+    write_visitor_decls("Dfg", DfgVertexList)
+    write_visitor_defns("Dfg", DfgVertexList, "DfgVisitor")
+    write_type_enum("Dfg", DfgVertexList)
+    write_type_tests("Dfg", DfgVertexList)
+    write_dfg_macros("V3Dfg__gen_macros.h")
+    write_dfg_auto_classes("V3Dfg__gen_auto_classes.h")
     write_dfg_ast_to_dfg("V3Dfg__gen_ast_to_dfg.h")
     write_dfg_dfg_to_ast("V3Dfg__gen_dfg_to_ast.h")