diff --git a/src/V3Active.cpp b/src/V3Active.cpp
index 177454dcf..1c499aecd 100644
--- a/src/V3Active.cpp
+++ b/src/V3Active.cpp
@@ -73,7 +73,7 @@ private:
 	m_scopep->addActivep(nodep);
     }
     // VISITORS
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	m_scopep = nodep;
 	m_iActivep = NULL;
 	m_cActivep = NULL;
@@ -81,15 +81,15 @@ private:
 	nodep->iterateChildren(*this);
 	// Don't clear scopep, the namer persists beyond this visit
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	// Simplify sensitivity list
 	V3Const::constifyExpensiveEdit(nodep); VL_DANGLING(nodep);
     }
     // Empty visitors, speed things up
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) { }
+    virtual void visit(AstNodeStmt* nodep) { }
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -169,7 +169,7 @@ private:
     AstNode*	m_alwaysp;	// Always we're under
     AstNode*	m_assignp;	// In assign
     // VISITORS
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	if (m_check != CT_SEQ) {
 	    // Convert to a non-delayed assignment
 	    UINFO(5,"    ASSIGNDLY "<<nodep<<endl);
@@ -187,7 +187,7 @@ private:
 	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstAssign* nodep, AstNUser*) {
+    virtual void visit(AstAssign* nodep) {
 	if (m_check == CT_SEQ) {
 	    AstNode* las = m_assignp;
 	    m_assignp = nodep;
@@ -195,7 +195,7 @@ private:
 	    m_assignp = las;
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	AstVar* varp=nodep->varp();
 	if (m_check == CT_SEQ
 	    && m_assignp
@@ -214,7 +214,7 @@ private:
 	}
     }
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -244,7 +244,7 @@ private:
     bool	m_itemSequent;	// Found a SenItem sequential
 
     // VISITORS
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// Create required actives and add to scope
 	UINFO(4," SCOPE   "<<nodep<<endl);
 	// Clear last scope's names, and collect this scope's existing names
@@ -252,10 +252,10 @@ private:
 	m_scopeFinalp = NULL;
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Actives are being formed, so we can ignore any already made
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	// Relink to IACTIVE, unless already under it
 	UINFO(4,"    INITIAL "<<nodep<<endl);
 	ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
@@ -263,28 +263,28 @@ private:
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	// Relink to CACTIVE, unless already under it
 	UINFO(4,"    ASSIGNW "<<nodep<<endl);
 	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	// Relink to CACTIVE, unless already under it
 	UINFO(4,"    ASSIGNW "<<nodep<<endl);
 	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	// Relink to CACTIVE, unless already under it
 	UINFO(4,"    COVERTOGGLE "<<nodep<<endl);
 	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	// Relink to CFUNC for the final
 	UINFO(4,"    FINAL "<<nodep<<endl);
 	if (!nodep->bodysp()) { // Empty, Kill it.
@@ -370,7 +370,7 @@ private:
 	    ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_SEQ);
 	}
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	// Move always to appropriate ACTIVE based on its sense list
 	UINFO(4,"    ALW   "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
@@ -382,13 +382,13 @@ private:
 	}
 	visitAlways(nodep, nodep->sensesp(), nodep->keyword());
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	// Move always to appropriate ACTIVE based on its sense list
 	UINFO(4,"    ALWPub   "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
 	visitAlways(nodep, nodep->sensesp(), VAlwaysKwd::ALWAYS);
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	AstSenItem* subitemp = nodep->sensesp();
 	if (subitemp->edgeType() != AstEdgeType::ET_ANYEDGE
 	    && subitemp->edgeType() != AstEdgeType::ET_POSEDGE
@@ -397,7 +397,7 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	if (nodep->edgeType() == AstEdgeType::ET_ANYEDGE) {
 	    m_itemCombo = true;
 	    // Delete the sensitivity
@@ -413,10 +413,10 @@ private:
     }
 
     // Empty visitors, speed things up
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstVarScope* nodep, AstNUser*) {}
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstVarScope* nodep) {}
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3ActiveTop.cpp b/src/V3ActiveTop.cpp
index 3827c05da..8935b851f 100644
--- a/src/V3ActiveTop.cpp
+++ b/src/V3ActiveTop.cpp
@@ -65,19 +65,19 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	m_topscopep = nodep;
 	m_finder.main(m_topscopep);
 	nodep->iterateChildren(*this);
 	m_topscopep = NULL;
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Create required actives and add to module
 	// We can start ordering at a module, or a scope
 	UINFO(4," MOD   "<<nodep<<endl);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	UINFO(4,"   ACTIVE "<<nodep<<endl);
 	V3Const::constifyExpensiveEdit(nodep); // Remove duplicate clocks and such; sensesp() may change!
 	AstSenTree* sensesp = nodep->sensesp();
@@ -120,29 +120,29 @@ private:
 	// No need to do statements under it, they're already moved.
 	//nodep->iterateChildren(*this);
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	nodep->v3fatalSrc("Node should have been deleted");
     }
     // Empty visitors, speed things up
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstVarScope* nodep, AstNUser*) {}
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstVarScope* nodep) {}
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Assert.cpp b/src/V3Assert.cpp
index 68c27bbf1..273570031 100644
--- a/src/V3Assert.cpp
+++ b/src/V3Assert.cpp
@@ -163,7 +163,7 @@ private:
 	pushDeletep(nodep); VL_DANGLING(nodep);
     }
     
-    virtual void visit(AstIf* nodep, AstNUser*) {
+    virtual void visit(AstIf* nodep) {
 	if (nodep->user1SetOnce()) return;
 	if (nodep->uniquePragma() || nodep->unique0Pragma()) {
 	    AstNodeIf* ifp = nodep;
@@ -220,7 +220,7 @@ private:
     }
 
     // VISITORS  //========== Case assertions
-    virtual void visit(AstCase* nodep, AstNUser*) {
+    virtual void visit(AstCase* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->user1SetOnce()) {
 	    bool has_default=false;
@@ -268,7 +268,7 @@ private:
     }
 
     // VISITORS  //========== Statements
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstDisplay* nodep) {
 	nodep->iterateChildren(*this);
 	// Replace the special types with standard text
 	if (nodep->displayType()==AstDisplayType::DT_INFO) {
@@ -281,27 +281,27 @@ private:
 	}
     }
 
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    virtual void visit(AstPslCover* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_beginp && nodep->name() == "") nodep->name(m_beginp->name());
 	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
 			nodep->stmtsp(), nodep->name()); VL_DANGLING(nodep);
 	++m_statAsCover;
     }
-    virtual void visit(AstVAssert* nodep, AstNUser*) {
+    virtual void visit(AstVAssert* nodep) {
 	nodep->iterateChildren(*this);
 	newVAssertion(nodep, nodep->propp()); VL_DANGLING(nodep);
 	++m_statAsSV;
     }
 
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	//
 	nodep->iterateChildren(*this);
 	// Reset defaults
 	m_modp = NULL;
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	// This code is needed rather than a visitor in V3Begin,
 	// because V3Assert is called before V3Begin
 	AstBegin* lastp = m_beginp;
@@ -312,7 +312,7 @@ private:
 	m_beginp = lastp;
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3AssertPre.cpp b/src/V3AssertPre.cpp
index b7d4a435e..1dd6c7332 100644
--- a/src/V3AssertPre.cpp
+++ b/src/V3AssertPre.cpp
@@ -73,7 +73,7 @@ private:
     }
 
     // VISITORS  //========== Statements
-    virtual void visit(AstClocking* nodep, AstNUser*) {
+    virtual void visit(AstClocking* nodep) {
 	UINFO(8,"   CLOCKING"<<nodep<<endl);
 	// Store the new default clock, reset on new module
 	m_seniDefaultp = nodep->sensesp();
@@ -86,14 +86,14 @@ private:
 	pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    virtual void visit(AstPslCover* nodep) {
 	if (nodep->sentreep()) return;  // Already processed
 	clearAssertInfo();
 	nodep->iterateChildren(*this);
 	nodep->sentreep(newSenTree(nodep));
 	clearAssertInfo();
     }
-    virtual void visit(AstPslClocked* nodep, AstNUser*) {
+    virtual void visit(AstPslClocked* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_senip) {
 	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion");
@@ -111,12 +111,12 @@ private:
 	nodep->replaceWith(blockp);
 	pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	nodep->iterateChildren(*this);
 	// Reset defaults
 	m_seniDefaultp = NULL;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Ast.cpp b/src/V3Ast.cpp
index 8a3d52689..0fa610241 100644
--- a/src/V3Ast.cpp
+++ b/src/V3Ast.cpp
@@ -732,31 +732,31 @@ void AstNode::operator delete(void* objp, size_t size) {
 //======================================================================
 // Iterators
 
-void AstNode::iterateChildren(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateChildren(AstNVisitor& v) {
     // This is a very hot function
     ASTNODE_PREFETCH(m_op1p);
     ASTNODE_PREFETCH(m_op2p);
     ASTNODE_PREFETCH(m_op3p);
     ASTNODE_PREFETCH(m_op4p);
-    if (m_op1p) m_op1p->iterateAndNext(v, vup);
-    if (m_op2p) m_op2p->iterateAndNext(v, vup);
-    if (m_op3p) m_op3p->iterateAndNext(v, vup);
-    if (m_op4p) m_op4p->iterateAndNext(v, vup);
+    if (m_op1p) m_op1p->iterateAndNext(v);
+    if (m_op2p) m_op2p->iterateAndNext(v);
+    if (m_op3p) m_op3p->iterateAndNext(v);
+    if (m_op4p) m_op4p->iterateAndNext(v);
 }
 
-void AstNode::iterateChildrenConst(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateChildrenConst(AstNVisitor& v) {
     // This is a very hot function
     ASTNODE_PREFETCH(m_op1p);
     ASTNODE_PREFETCH(m_op2p);
     ASTNODE_PREFETCH(m_op3p);
     ASTNODE_PREFETCH(m_op4p);
-    if (m_op1p) m_op1p->iterateAndNextConst(v, vup);
-    if (m_op2p) m_op2p->iterateAndNextConst(v, vup);
-    if (m_op3p) m_op3p->iterateAndNextConst(v, vup);
-    if (m_op4p) m_op4p->iterateAndNextConst(v, vup);
+    if (m_op1p) m_op1p->iterateAndNextConst(v);
+    if (m_op2p) m_op2p->iterateAndNextConst(v);
+    if (m_op3p) m_op3p->iterateAndNextConst(v);
+    if (m_op4p) m_op4p->iterateAndNextConst(v);
 }
 
-void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateAndNext(AstNVisitor& v) {
     // This is a very hot function
     // IMPORTANT: If you replace a node that's the target of this iterator,
     // then the NEW node will be iterated on next, it isn't skipped!
@@ -773,7 +773,7 @@ void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
 	//if (VL_UNLIKELY(niterp->m_iterpp)) niterp->v3fatalSrc("IterateAndNext under iterateAndNext may miss edits");
 	// cppcheck-suppress nullPointer
 	niterp->m_iterpp = &niterp;
-	niterp->accept(v, vup);
+	niterp->accept(v);
 	// accept may do a replaceNode and change niterp on us...
 	//if (niterp != nodep) UINFO(1,"iterateAndNext edited "<<(void*)nodep<<" now into "<<(void*)niterp<<endl);  // niterp maybe NULL, so need cast
 	if (!niterp) return;  // Perhaps node deleted inside accept
@@ -786,37 +786,37 @@ void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
     }
 }
 
-void AstNode::iterateListBackwards(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateListBackwards(AstNVisitor& v) {
     UDEBUGONLY(UASSERT(dynamic_cast<AstNode*>(this),"this should not be NULL"););
     AstNode* nodep=this;
     while (nodep->m_nextp) nodep=nodep->m_nextp;
     while (nodep) {
 	// Edits not supported: nodep->m_iterpp = &nodep;
-	nodep->accept(v, vup);
+	nodep->accept(v);
 	if (nodep->backp()->m_nextp == nodep) nodep=nodep->backp();
 	else nodep = NULL;  // else: backp points up the tree.
     }
 }
 
-void AstNode::iterateChildrenBackwards(AstNVisitor& v, AstNUser* vup) {
-    if (m_op1p) m_op1p->iterateListBackwards(v,vup);
-    if (m_op2p) m_op2p->iterateListBackwards(v,vup);
-    if (m_op3p) m_op3p->iterateListBackwards(v,vup);
-    if (m_op4p) m_op4p->iterateListBackwards(v,vup);
+void AstNode::iterateChildrenBackwards(AstNVisitor& v) {
+    if (m_op1p) m_op1p->iterateListBackwards(v);
+    if (m_op2p) m_op2p->iterateListBackwards(v);
+    if (m_op3p) m_op3p->iterateListBackwards(v);
+    if (m_op4p) m_op4p->iterateListBackwards(v);
 }
 
-void AstNode::iterateAndNextConst(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateAndNextConst(AstNVisitor& v) {
     // Keep following the current list even if edits change it
     if (!this) return;  // A few cases could be cleaned up, but want symmetry with iterateAndNext
     for (AstNode* nodep=this; nodep; ) {   // effectively: if (!this) return;  // Callers rely on this
 	AstNode* nnextp = nodep->m_nextp;
 	ASTNODE_PREFETCH(nnextp);
-	nodep->accept(v, vup);
+	nodep->accept(v);
 	nodep = nnextp;
     }
 }
 
-AstNode* AstNode::iterateSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
+AstNode* AstNode::iterateSubtreeReturnEdits(AstNVisitor& v) {
     // Some visitors perform tree edits (such as V3Const), and may even
     // replace/delete the exact nodep that the visitor is called with.  If
     // this happens, the parent will lose the handle to the node that was
@@ -826,12 +826,12 @@ AstNode* AstNode::iterateSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
     AstNode* nodep = this;  // Note "this" may point to bogus point later in this function
     if (nodep->castNetlist()) {
 	// Calling on top level; we know the netlist won't get replaced
-	nodep->accept(v, vup);
+	nodep->accept(v);
     } else if (!nodep->backp()) {
 	// Calling on standalone tree; insert a shim node so we can keep track, then delete it on completion
 	AstBegin* tempp = new AstBegin(nodep->fileline(),"[EditWrapper]",nodep);
 	{
-	    tempp->stmtsp()->accept(v, vup); VL_DANGLING(nodep); // nodep to null as may be replaced
+	    tempp->stmtsp()->accept(v); VL_DANGLING(nodep); // nodep to null as may be replaced
 	}
 	nodep = tempp->stmtsp()->unlinkFrBackWithNext();
 	tempp->deleteTree(); VL_DANGLING(tempp);
@@ -845,7 +845,7 @@ AstNode* AstNode::iterateSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
 	else if (this->m_backp->m_nextp == this) nextnodepp = &(this->m_backp->m_nextp);
 	if (!nextnodepp) this->v3fatalSrc("Node's back doesn't point to forward to node itself");
 	{
-	    nodep->accept(v, vup); VL_DANGLING(nodep); // nodep to null as may be replaced
+	    nodep->accept(v); VL_DANGLING(nodep); // nodep to null as may be replaced
 	}
 	nodep = *nextnodepp;  // Grab new node from point where old was connected
     }
diff --git a/src/V3Ast.h b/src/V3Ast.h
index 34ee04451..5a2d98dd5 100644
--- a/src/V3Ast.h
+++ b/src/V3Ast.h
@@ -862,8 +862,8 @@ public:
     }
 #include "V3Ast__gen_visitor.h"	// From ./astgen
     // Things like:
-    //  virtual void visit(AstBreak* nodep, AstNUser* vup) { visit((AstNodeStmt*)(nodep),vup); }
-    //  virtual void visit(AstNodeStmt* nodep, AstNUser* vup) { visit((AstNode*)(nodep),vup); }
+    //  virtual void visit(AstBreak* nodep) { visit((AstNodeStmt*)(nodep)); }
+    //  virtual void visit(AstNodeStmt* nodep) { visit((AstNode*)(nodep)); }
 };
 
 //######################################################################
@@ -993,7 +993,7 @@ class AstNode {
     void	op4p(AstNode* nodep) { m_op4p = nodep; if (nodep) nodep->m_backp = this; }
 
     void	init();	// initialize value of AstNode
-    void	iterateListBackwards(AstNVisitor& v, AstNUser* vup=NULL);
+    void	iterateListBackwards(AstNVisitor& v);
 private:
     AstNode*	cloneTreeIter();
     AstNode*	cloneTreeIterList();
@@ -1265,14 +1265,14 @@ public:
     virtual const char* broken() const { return NULL; }
 
     // INVOKERS
-    virtual void accept(AstNVisitor& v, AstNUser* vup=NULL) = 0;
-    void	iterate(AstNVisitor& v, AstNUser* vup=NULL) { this->accept(v,vup); } 	  // Does this; excludes following this->next
-    void	iterateAndNext(AstNVisitor& v, AstNUser* vup=NULL);
-    void	iterateAndNextConst(AstNVisitor& v, AstNUser* vup=NULL);
-    void	iterateChildren(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
-    void	iterateChildrenBackwards(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
-    void	iterateChildrenConst(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
-    AstNode*	iterateSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup=NULL);  // Return edited nodep; see comments in V3Ast.cpp
+    virtual void accept(AstNVisitor& v) = 0;
+    void	iterate(AstNVisitor& v) { this->accept(v); } 	  // Does this; excludes following this->next
+    void	iterateAndNext(AstNVisitor& v);
+    void	iterateAndNextConst(AstNVisitor& v);
+    void	iterateChildren(AstNVisitor& v);  // Excludes following this->next
+    void	iterateChildrenBackwards(AstNVisitor& v);  // Excludes following this->next
+    void	iterateChildrenConst(AstNVisitor& v);  // Excludes following this->next
+    AstNode*	iterateSubtreeReturnEdits(AstNVisitor& v);  // Return edited nodep; see comments in V3Ast.cpp
 
     // CONVERSION
 #include "V3Ast__gen_interface.h"	// From ./astgen
@@ -1318,7 +1318,7 @@ public:
     // Know no children, and hot function, so skip iterator for speed
     // See checkTreeIter also that asserts no children
     // cppcheck-suppress functionConst
-    void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
+    void iterateChildren(AstNVisitor& v) { }
 };
 
 class AstNodeUniop : public AstNodeMath {
@@ -1602,7 +1602,7 @@ public:
     // Know no children, and hot function, so skip iterator for speed
     // See checkTreeIter also that asserts no children
     // cppcheck-suppress functionConst
-    void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
+    void iterateChildren(AstNVisitor& v) { }
 };
 
 class AstNodeText : public AstNode {
diff --git a/src/V3AstNodes.h b/src/V3AstNodes.h
index 6c688a425..811f453ab 100644
--- a/src/V3AstNodes.h
+++ b/src/V3AstNodes.h
@@ -32,7 +32,7 @@
     virtual ~Ast ##name() {} \
     virtual AstType type() const { return AstType::at ## name; } \
     virtual AstNode* clone() { return new Ast ##name (*this); } \
-    virtual void accept(AstNVisitor& v, AstNUser* vup=NULL) { v.visit(this,vup); } \
+    virtual void accept(AstNVisitor& v) { v.visit(this); } \
     Ast ##name * cloneTree(bool cloneNext) { return static_cast<Ast ##name *>(AstNode::cloneTree(cloneNext)); } \
     Ast ##name * clonep() const { return static_cast<Ast ##name *>(AstNode::clonep()); }
 
diff --git a/src/V3Begin.cpp b/src/V3Begin.cpp
index 8b460577a..e07e6b1b1 100644
--- a/src/V3Begin.cpp
+++ b/src/V3Begin.cpp
@@ -84,13 +84,13 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_repeatNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	UINFO(8,"  "<<nodep<<endl);
 	// Rename it
 	if (m_unnamedScope != "") {
@@ -113,7 +113,7 @@ private:
 	m_namedScope = oldScope;
 	m_unnamedScope = oldUnnamed;
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	// Begin blocks were only useful in variable creation, change names and delete
 	UINFO(8,"  "<<nodep<<endl);
 	string oldScope = m_namedScope;
@@ -162,7 +162,7 @@ private:
 	}
 	pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	if (m_unnamedScope != "") {
 	    // Rename it
 	    nodep->name(m_unnamedScope+"__DOT__"+nodep->name());
@@ -173,7 +173,7 @@ private:
 	    else m_modp->addStmtp(nodep);
 	}
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	UINFO(8,"   CELL "<<nodep<<endl);
 	if (m_namedScope != "") {
 	    m_statep->userMarkChanged(nodep);
@@ -186,14 +186,14 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	UINFO(9, "   VARXREF "<<nodep<<endl);
 	if (m_namedScope != "" && nodep->inlinedDots() == "") {
 	    nodep->inlinedDots(m_namedScope);
 	    UINFO(9, "    rescope to "<<nodep<<endl);
 	}
     }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
 	// If there's a %m in the display text, we add a special node that will contain the name()
 	// Similar code in V3Inline
 	if (nodep->user1SetOnce()) return;  // Don't double-add text's
@@ -206,13 +206,13 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+    virtual void visit(AstCoverDecl* nodep) {
 	// Don't need to fix path in coverage statements, they're not under
 	// any BEGINs, but V3Coverage adds them all under the module itself.
 	nodep->iterateChildren(*this);
     }
     // VISITORS - LINT CHECK
-    virtual void visit(AstIf* nodep, AstNUser*) { // Note not AstNodeIf; other types don't get covered
+    virtual void visit(AstIf* nodep) { // Note not AstNodeIf; other types don't get covered
 	// Check IFDEPTH warning - could be in other transform files if desire
 	int prevIfDepth = m_ifDepth;
 	if (m_ifDepth == -1 || v3Global.opt.ifDepth()<1) { // Turned off
@@ -226,7 +226,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_ifDepth = prevIfDepth;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -252,21 +252,21 @@ private:
     //   AstNodeFTask::user1p		// Node replaced, rename it
 
     // VISITORS
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	if (nodep->taskp()->user1()) { // It was converted
 	    UINFO(9, "    relinkFTask "<<nodep<<endl);
 	    nodep->name(nodep->taskp()->name());
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()->user1()) { // It was converted
 	    UINFO(9, "    relinVarRef "<<nodep<<endl);
 	    nodep->name(nodep->varp()->name());
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstIfaceRefDType* nodep, AstNUser*) {
+    virtual void visit(AstIfaceRefDType* nodep) {
 	// May have changed cell names
 	// TypeTable is always after all modules, so names are stable
 	UINFO(8,"   IFACEREFDTYPE "<<nodep<<endl);
@@ -275,7 +275,7 @@ private:
 	nodep->iterateChildren(*this);
     }
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Branch.cpp b/src/V3Branch.cpp
index f37a83430..6f38afd70 100644
--- a/src/V3Branch.cpp
+++ b/src/V3Branch.cpp
@@ -75,7 +75,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	UINFO(4," IF: "<<nodep<<endl);
 	int lastLikely = m_likely;
 	int lastUnlikely = m_unlikely;
@@ -101,17 +101,17 @@ private:
 	m_likely = lastLikely;
 	m_unlikely = lastUnlikely;
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	checkUnlikely(nodep);
 	nodep->funcp()->user1Inc();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	checkUnlikely(nodep);
 	m_cfuncsp.push_back(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	checkUnlikely(nodep);
 	nodep->iterateChildren(*this);
     }
diff --git a/src/V3Broken.cpp b/src/V3Broken.cpp
index ecca48f9b..48c2725a7 100644
--- a/src/V3Broken.cpp
+++ b/src/V3Broken.cpp
@@ -192,7 +192,7 @@ private:
 	nodep->iterateChildrenConst(*this);
     }
     // VISITORS
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	processAndIterate(nodep);
     }
 public:
@@ -236,7 +236,7 @@ private:
 	nodep->iterateChildrenConst(*this);
 	BrokenTable::setUnder(nodep,false);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	processAndIterate(nodep);
     }
 public:
diff --git a/src/V3Case.cpp b/src/V3Case.cpp
index 7efbe1f97..99c28b06d 100644
--- a/src/V3Case.cpp
+++ b/src/V3Case.cpp
@@ -65,7 +65,7 @@ private:
 	return level;
     }
 
-    virtual void visit(AstNodeCase* nodep, AstNUser*) {
+    virtual void visit(AstNodeCase* nodep) {
 	if (nodep->castCase() && nodep->castCase()->casex()) {
 	    nodep->v3warn(CASEX,"Suggest casez (with ?'s) in place of casex (with X's)");
 	}
@@ -90,7 +90,7 @@ private:
 	    m_caseExprp = NULL;
 	}
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	// See also neverItem
 	if (m_caseExprp && nodep->num().isFourState()) {
 	    if (m_caseExprp->castGenCase()) {
@@ -107,7 +107,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -451,7 +451,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCase* nodep, AstNUser*) {
+    virtual void visit(AstCase* nodep) {
 	V3Case::caseLint(nodep);
 	nodep->iterateChildren(*this);
 	if (debug()>=9) nodep->dumpTree(cout," case_old: ");
@@ -467,7 +467,7 @@ private:
     }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Cast.cpp b/src/V3Cast.cpp
index 78cc30b4a..75d4c6b63 100644
--- a/src/V3Cast.cpp
+++ b/src/V3Cast.cpp
@@ -107,19 +107,19 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
     }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1()
 		    | nodep->rhsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
 	if (nodep->sizeMattersRhs()) insureCast(nodep->rhsp());
     }
-    virtual void visit(AstNodeTriop* nodep, AstNUser*) {
+    virtual void visit(AstNodeTriop* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1()
 		    | nodep->rhsp()->user1()
@@ -128,12 +128,12 @@ private:
 	if (nodep->sizeMattersRhs()) insureCast(nodep->rhsp());
 	if (nodep->sizeMattersThs()) insureCast(nodep->thsp());
     }
-    virtual void visit(AstCCast* nodep, AstNUser*) {
+    virtual void visit(AstCCast* nodep) {
 	nodep->iterateChildren(*this);
 	insureLower32Cast(nodep);
 	nodep->user1(1);
     }
-    virtual void visit(AstNegate* nodep, AstNUser*) {
+    virtual void visit(AstNegate* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->lhsp()->widthMin()==1) {
@@ -145,7 +145,7 @@ private:
 	    insureCast(nodep->lhsp());
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (!nodep->lvalue()
 	    && !nodep->backp()->castCCast()
 	    && nodep->backp()->castNodeMath()
@@ -158,7 +158,7 @@ private:
 	}
 	nodep->user1(1);
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	// Constants are of unknown size if smaller than 33 bits, becase
 	// we're too lazy to wrap every constant in the universe in
 	// ((IData)#).
@@ -166,11 +166,11 @@ private:
     }
 
     // NOPs
-    virtual void visit(AstVar* nodep, AstNUser*) {}
+    virtual void visit(AstVar* nodep) {}
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Cdc.cpp b/src/V3Cdc.cpp
index 4e5c89426..96dfd3224 100644
--- a/src/V3Cdc.cpp
+++ b/src/V3Cdc.cpp
@@ -138,7 +138,7 @@ private:
     ofstream*		m_ofp;		// Output file
     string		m_prefix;
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	*m_ofp<<m_prefix;
 	if (nodep->user3()) *m_ofp<<" %%";
 	else *m_ofp<<"  ";
@@ -172,7 +172,7 @@ private:
     int		m_maxLineno;
     size_t	m_maxFilenameLen;
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	// Keeping line+filename lengths separate is much faster than calling ascii().length()
 	if (nodep->fileline()->lineno() >= m_maxLineno) {
@@ -604,19 +604,19 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(4," SCOPE "<<nodep<<endl);
 	m_scopep = nodep;
 	m_logicVertexp = NULL;
 	nodep->iterateChildren(*this);
 	m_scopep = NULL;
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Create required blocks and add to module
 	UINFO(4,"  BLOCK  "<<nodep<<endl);
 	AstNode::user2ClearTree();
@@ -627,7 +627,7 @@ private:
 	m_domainp = NULL;
 	AstNode::user2ClearTree();
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	if (m_scopep) {
 	    if (!m_logicVertexp) nodep->v3fatalSrc("Var ref not under a logic block\n");
 	    AstVarScope* varscp = nodep->varScopep();
@@ -655,72 +655,72 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	m_inDly = true;
 	nodep->iterateChildren(*this);
 	m_inDly = false;
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	// Note we look at only AstSenItems, not AstSenGate's
 	// The gating term of a AstSenGate is normal logic
 	m_inSenItem = true;
 	nodep->iterateChildren(*this);
 	m_inSenItem = false;
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	// CDC doesn't care about public variables
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	// First handle the clock part will be handled in a minute by visit AstSenItem
 	// The logic gating term is delt with as logic
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	iterateNewStmt(nodep);
     }
 
     // Math that shouldn't cause us to clear hazard
-    virtual void visit(AstConst* nodep, AstNUser*) { }
-    virtual void visit(AstReplicate* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) { }
+    virtual void visit(AstReplicate* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstConcat* nodep, AstNUser*) {
+    virtual void visit(AstConcat* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNot* nodep, AstNUser*) {
+    virtual void visit(AstNot* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	if (!nodep->lsbp()->castConst()) setNodeHazard(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeSel* nodep, AstNUser*) {
+    virtual void visit(AstNodeSel* nodep) {
 	if (!nodep->bitp()->castConst()) setNodeHazard(nodep);
 	nodep->iterateChildren(*this);
     }
 
     // Ignores
-    virtual void visit(AstInitial* nodep, AstNUser*) { }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) { }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) { }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) { }
+    virtual void visit(AstInitial* nodep) { }
+    virtual void visit(AstTraceInc* nodep) { }
+    virtual void visit(AstCoverToggle* nodep) { }
+    virtual void visit(AstNodeDType* nodep) { }
 
     //--------------------
     // Default
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	setNodeHazard(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Changed.cpp b/src/V3Changed.cpp
index 738d4241b..2251e03b5 100644
--- a/src/V3Changed.cpp
+++ b/src/V3Changed.cpp
@@ -143,13 +143,13 @@ private:
 	m_statep->m_numStmts += visitor.count();
     }
 
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	newChangeDet();
     }
-    virtual void visit(AstPackArrayDType* nodep, AstNUser*) {
+    virtual void visit(AstPackArrayDType* nodep) {
 	newChangeDet();
     }
-    virtual void visit(AstUnpackArrayDType* nodep, AstNUser*) {
+    virtual void visit(AstUnpackArrayDType* nodep) {
 	for (int index=0; index < nodep->elementsConst(); ++index) {
 	    AstNode* origVEp = m_varEqnp;
 	    AstNode* origNLEp = m_newLvEqnp;
@@ -170,7 +170,7 @@ private:
 	    m_newRvEqnp = origNREp;
 	}
     }
-    virtual void visit(AstNodeClassDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeClassDType* nodep) {
 	if (nodep->packedUnsup()) {
 	    newChangeDet();
 	} else {
@@ -178,7 +178,7 @@ private:
 	    m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable (probably with UNOPTFLAT warning suppressed): "<<m_vscp->varp()->prettyName());
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	if (debug()) nodep->dumpTree(cout,"-DETECTARRAY-general-");
 	m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable (probably with UNOPTFLAT warning suppressed): "<<m_vscp->varp()->prettyName());
@@ -239,7 +239,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	if (nodep->isTop()) {
 	    m_statep->m_topModp = nodep;
@@ -247,7 +247,7 @@ private:
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	UINFO(4," TS "<<nodep<<endl);
 	// Clearing
 	AstNode::user1ClearTree();
@@ -269,7 +269,7 @@ private:
 
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	if (nodep->isCircular()) {
 	    UINFO(8,"  CIRC "<<nodep<<endl);
 	    if (!nodep->user1SetOnce()) {
@@ -277,12 +277,12 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	// Short-circuit 
     }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Clean.cpp b/src/V3Clean.cpp
index bfa0b0564..948f9f479 100644
--- a/src/V3Clean.cpp
+++ b/src/V3Clean.cpp
@@ -173,12 +173,12 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
 	if (nodep->cleanLhs()) {
@@ -186,45 +186,45 @@ private:
 	}
 	setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstAnd* nodep, AstNUser*) {
+    virtual void visit(AstAnd* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, isClean(nodep->lhsp()) || isClean(nodep->rhsp()));
     }
-    virtual void visit(AstXor* nodep, AstNUser*) {
+    virtual void visit(AstXor* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
-    virtual void visit(AstOr* nodep, AstNUser*) {
+    virtual void visit(AstOr* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
         setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
 	if (nodep->cleanRhs()) {
 	    insureClean(nodep->rhsp());
 	}
     }
-    virtual void visit(AstText* nodep, AstNUser*) {
+    virtual void visit(AstText* nodep) {
 	setClean (nodep, true);
     }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
 	setClean (nodep, true);
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	operandTriop(nodep);
         setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
         setClean (nodep, false);
@@ -234,43 +234,43 @@ private:
 	}
 	insureCleanAndNext (nodep->bodysp());
     }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) {
+    virtual void visit(AstTraceInc* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->valuep());
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstTypedef* nodep) {
 	// No cleaning, or would loose pointer to enum
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstParamTypeDType* nodep, AstNUser*) {
+    virtual void visit(AstParamTypeDType* nodep) {
 	// No cleaning, or would loose pointer to enum
 	nodep->iterateChildren(*this);
     }
 
     // Control flow operators
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	nodep->iterateChildren(*this);
 	insureClean(nodep->condp());
 	setClean(nodep, isClean(nodep->expr1p()) && isClean(nodep->expr2p()));
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	nodep->iterateChildren(*this);
 	insureClean(nodep->condp());
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	nodep->iterateChildren(*this);
 	insureClean(nodep->condp());
     }
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->exprsp());
 	setClean(nodep, true);  // generates a string, so not relevant
     }
-    virtual void visit(AstUCStmt* nodep, AstNUser*) {
+    virtual void visit(AstUCStmt* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->bodysp());
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->argsp());
 	setClean (nodep, true);
@@ -278,7 +278,7 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
     }
diff --git a/src/V3ClkGater.cpp b/src/V3ClkGater.cpp
index cf99f0702..326b9f555 100644
--- a/src/V3ClkGater.cpp
+++ b/src/V3ClkGater.cpp
@@ -199,19 +199,19 @@ private:
 	if (m_isSimple) nodep->iterateChildren(*this);
     }
     // VISITORS
-    virtual void visit(AstOr* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstAnd* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstNot* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstLogOr* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstLogAnd* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstLogNot* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstOr* nodep) {	okIterate(nodep); }
+    virtual void visit(AstAnd* nodep) {	okIterate(nodep); }
+    virtual void visit(AstNot* nodep) {	okIterate(nodep); }
+    virtual void visit(AstLogOr* nodep) {	okIterate(nodep); }
+    virtual void visit(AstLogAnd* nodep) {	okIterate(nodep); }
+    virtual void visit(AstLogNot* nodep) {	okIterate(nodep); }
+    virtual void visit(AstVarRef* nodep) {	okIterate(nodep); }
 
     // Other possibilities are equals, etc
     // But, we don't want to get too complicated or it will take too much
     // effort to calculate the gater
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	m_isSimple = false;
 	//nodep->iterateChildren(*this);
     }
@@ -248,7 +248,7 @@ class GaterBodyVisitor : public GaterBaseVisitor {
     uint32_t	m_state;	// Parsing state
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->lvalue()) {
 	    AstVarScope* vscp = nodep->varScopep();
 	    if (vscp->user2p()->castNode() == m_exprp) {
@@ -272,11 +272,11 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	}
     }
 
-    //virtual void visit(AstNodeIf* nodep, AstNUser*) { ... }
+    //virtual void visit(AstNodeIf* nodep) { ... }
     // Not needed, it's the same handling as any other statement.  Cool, huh?
     // (We may get empty IFs but the constant propagater will rip them up for us)
 
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	uint32_t oldstate = m_state;
 	// Find if children want to delete this or not.
 	// Note children may bicker, and want to both keep and delete (branches on a if)
@@ -304,7 +304,7 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	    m_state |= STATE_KEEP;
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -701,7 +701,7 @@ class GaterVisitor : public GaterBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	if (debug()>=9) cout<<endl<<endl<<endl;
 	UINFO(5, "Gater: ALWAYS: "<<nodep<<endl);
 	if (nodep->user4SetOnce()) return;
@@ -751,7 +751,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	}
 	UINFO(5, "  Gater done"<<endl);
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->lvalue()) {
 	    AstVarScope* vscp = nodep->varScopep();
 	    if (nodep->varp()->isSigPublic()) {
@@ -778,7 +778,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    }
 	}
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	m_ifDepth++;
 	bool allowGater = m_directlyUnderAlw && m_ifDepth <= IF_DEPTH_MAX;
 	if (allowGater) {
@@ -819,12 +819,12 @@ class GaterVisitor : public GaterBaseVisitor {
 	m_ifDepth--;
     }
 
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	// iterateChildrenAlw will detect this is a statement for us
 	iterateChildrenAlw(nodep, false);
     }
 
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	// Note NOT AssignDly; handled above, We'll just mark this block as
 	// not optimizable.
 	//
@@ -836,7 +836,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	// No reason to iterate.
     }
 
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	if (!nodep->isClocked()) {
 	    nonOptimizable(nodep, "Non-clocked sensitivity");
 	}
@@ -844,7 +844,7 @@ class GaterVisitor : public GaterBaseVisitor {
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	if (m_nonopt=="") {  // Else accelerate
 	    iterateChildrenAlw(nodep, false);
 	}
diff --git a/src/V3Clock.cpp b/src/V3Clock.cpp
index f1e17a9f4..ce22030da 100644
--- a/src/V3Clock.cpp
+++ b/src/V3Clock.cpp
@@ -182,7 +182,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	UINFO(4," TOPSCOPE   "<<nodep<<endl);
 	m_topScopep=nodep;
 	m_scopep = nodep->scopep();
@@ -243,14 +243,14 @@ private:
 	m_topScopep=NULL;
 	m_scopep = NULL;
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	//UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_stableNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp= NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	//UINFO(4," SCOPE   "<<nodep<<endl);
 	m_scopep = nodep;
 	nodep->iterateChildren(*this);
@@ -261,7 +261,7 @@ private:
 	}
 	m_scopep = NULL;
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
 	nodep->replaceWith(cmtp);
 	if (AstNode* stmtsp = nodep->bodysp()) {
@@ -270,7 +270,7 @@ private:
 	}
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstAlwaysPost* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPost* nodep) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
 	nodep->replaceWith(cmtp);
 	if (AstNode* stmtsp = nodep->bodysp()) {
@@ -279,7 +279,7 @@ private:
 	}
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	//nodep->dumpTree(cout,"ct:");
 	//COVERTOGGLE(INC, ORIG, CHANGE) ->
 	//   IF(ORIG ^ CHANGE) { INC; CHANGE = ORIG; }
@@ -299,7 +299,7 @@ private:
 				    origp->cloneTree(false)));
 	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
 	nodep->replaceWith(cmtp);
 	if (AstNode* stmtsp = nodep->bodysp()) {
@@ -308,7 +308,7 @@ private:
 	}
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	nodep->iterateChildren(*this);
 	// Link to global function
 	if (nodep->formCallTree()) {
@@ -318,7 +318,7 @@ private:
 	    m_finalFuncp->addStmtsp(callp);
 	}
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	// Delete it later; Actives still pointing to it
 	nodep->unlinkFrBack();
 	pushDeletep(nodep);
@@ -335,7 +335,7 @@ private:
 	if (m_untilp) m_untilp->addBodysp(stmtsp);  // In a until loop, add to body
 	else m_initFuncp->addStmtsp(stmtsp);  // else add to top level function
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Careful if adding variables here, ACTIVES can be under other ACTIVES
 	// Need to save and restore any member state in AstUntilStable block
 	if (!m_topScopep || !nodep->stmtsp()) {
@@ -380,7 +380,7 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Combine.cpp b/src/V3Combine.cpp
index 69d5fc69f..017fee580 100644
--- a/src/V3Combine.cpp
+++ b/src/V3Combine.cpp
@@ -134,13 +134,13 @@ public:
     }
 private:
     // VISITORS
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	addCall(nodep);
     }
     // Speed things up
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {}
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {}
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -163,7 +163,7 @@ private:
     // OUTPUT:
     //  AstNode::user3()	-> bool. True to indicate duplicated
     // VISITORS
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->user3(true);
 	nodep->iterateChildren(*this);
     }
@@ -389,7 +389,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Track all callers of each function
 	m_call.main(nodep);
 	//
@@ -398,7 +398,7 @@ private:
 	// Required so that a module instantiating another can benefit from collapsing.
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_modNFuncs = 0;
@@ -426,7 +426,7 @@ private:
 	}
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	m_funcp = nodep;
 	if (!nodep->dontCombine()) {
 	    if (m_state == STATE_HASH) {
@@ -437,7 +437,7 @@ private:
 	}
 	m_funcp = NULL;
     }
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	if (m_state == STATE_HASH && m_funcp) {
 	    hashStatement(nodep);
 	}
@@ -448,10 +448,10 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar*, AstNUser*) {}
-    virtual void visit(AstTraceDecl*, AstNUser*) {}
-    virtual void visit(AstTraceInc*, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}
+    virtual void visit(AstTraceDecl*) {}
+    virtual void visit(AstTraceInc*) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Const.cpp b/src/V3Const.cpp
index 7cc9e8c5a..6ac4bd823 100644
--- a/src/V3Const.cpp
+++ b/src/V3Const.cpp
@@ -47,10 +47,10 @@ class ConstVarMarkVisitor : public AstNVisitor {
     // AstVar::user4p		-> bool, Var marked, 0=not set yet
 private:
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()) nodep->varp()->user4(1);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -69,17 +69,17 @@ class ConstVarFindVisitor : public AstNVisitor {
     bool m_found;
 private:
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp() && nodep->varp()->user4()) m_found = true;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
     explicit ConstVarFindVisitor(AstNode* nodep) {
 	m_found = false;
-	nodep->iterateAndNext(*this, NULL);
+	nodep->iterateAndNext(*this);
     }
     virtual ~ConstVarFindVisitor() {}
     // METHODS
@@ -1195,23 +1195,23 @@ private:
     //----------------------------------------
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Iterate modules backwards, in bottom-up order.  That's faster
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	// No ASSIGNW removals under funcs, we've long eliminated INITIALs
 	// (We should perhaps rename the assignw's to just assigns)
 	m_wremove = false;
 	nodep->iterateChildren(*this);
 	m_wremove = true;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// No ASSIGNW removals under scope, we've long eliminated INITIALs
 	m_scopep = nodep;
 	m_wremove = false;
@@ -1284,16 +1284,16 @@ private:
     }
 
     // Special cases
-    virtual void visit(AstConst* nodep, AstNUser*) {}	// Already constant
+    virtual void visit(AstConst* nodep) {}	// Already constant
 
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	if (m_params) {
 	    nodep->paramsp()->iterateAndNext(*this);
 	} else {
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -1414,14 +1414,14 @@ private:
 	nodep->replaceWith(fromp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
-    virtual void visit(AstAttrOf* nodep, AstNUser*) {
+    virtual void visit(AstAttrOf* nodep) {
 	AstAttrOf* oldAttr = m_attrp;
 	m_attrp = nodep;
 	nodep->iterateChildren(*this);
 	m_attrp = oldAttr;
     }
 
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	nodep->bitp()->iterateAndNext(*this);
 	if (nodep->bitp()->castConst()
 	    && nodep->fromp()->castVarRef()
@@ -1440,7 +1440,7 @@ private:
 	}
 	m_selp = NULL;
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->varp()) nodep->v3fatalSrc("Not linked");
 	bool did=false;
@@ -1492,7 +1492,7 @@ private:
 	    nodep->v3error("Expecting expression to be constant, but variable isn't const: "<<nodep->varp()->prettyName());
 	}
     }
-    virtual void visit(AstEnumItemRef* nodep, AstNUser*) {
+    virtual void visit(AstEnumItemRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->itemp()) nodep->v3fatalSrc("Not linked");
 	bool did=false;
@@ -1510,7 +1510,7 @@ private:
 	}
     }
 
-    // virtual void visit(AstCvtPackString* nodep, AstNUser*) {
+    // virtual void visit(AstCvtPackString* nodep) {
     // Not constant propagated (for today) because AstMath::isOpaque is set
     // Someday if lower is constant, convert to quoted "string".
 
@@ -1518,7 +1518,7 @@ private:
 	// Only one if it's not in a list
 	return (!nodep->nextp() && nodep->backp()->nextp() != nodep);
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst
 	    && (nodep->sensp()->castConst()
@@ -1558,7 +1558,7 @@ private:
 	    if (nodep->hasVar() && !nodep->varrefp()) nodep->v3fatalSrc("Null sensitivity variable");
 	}
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	nodep->iterateChildren(*this);
 	if (AstConst* constp = nodep->rhsp()->castConst()) {
 	    if (constp->isZero()) {
@@ -1604,7 +1604,7 @@ private:
 	}
     };
 
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doExpensive) {
 	    //cout<<endl; nodep->dumpTree(cout,"ssin: ");
@@ -1708,17 +1708,17 @@ private:
 
     //-----
     // Zero elimination
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst && replaceNodeAssign(nodep)) return;
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	// Don't perform any optimizations, keep the alias around
     }
-    virtual void visit(AstAssignVarScope* nodep, AstNUser*) {
+    virtual void visit(AstAssignVarScope* nodep) {
 	// Don't perform any optimizations, the node won't be linked yet
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst && replaceNodeAssign(nodep)) return;
 	AstNodeVarRef* varrefp = nodep->lhsp()->castVarRef();  // Not VarXRef, as different refs may set different values to each hierarchy
@@ -1745,7 +1745,7 @@ private:
 	}
     }
 
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst) {
 	    if (AstConst* constp = nodep->condp()->castConst()) {
@@ -1823,7 +1823,7 @@ private:
 	}
     }
 
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	// Substitute constants into displays.  The main point of this is to
 	// simplify assertion methodologies which call functions with display's.
 	// This eliminates a pile of wide temps, and makes the C a whole lot more readable.
@@ -1885,17 +1885,17 @@ private:
 	}
     }
 
-    virtual void visit(AstFuncRef* nodep, AstNUser*) {
+    virtual void visit(AstFuncRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_params) {  // Only parameters force us to do constant function call propagation
 	    replaceWithSimulation(nodep);
 	}
     }
-    virtual void visit(AstArg* nodep, AstNUser*) {
+    virtual void visit(AstArg* nodep) {
 	// replaceWithSimulation on the Arg's parent FuncRef replaces these
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst) {
 	    if (nodep->condp()->isZero()) {
@@ -1909,17 +1909,17 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstInitArray* nodep, AstNUser*) {
+    virtual void visit(AstInitArray* nodep) {
 	// Constant if all children are constant
 	nodep->iterateChildren(*this);
     }
 
     // These are converted by V3Param.  Don't constify as we don't want the from() VARREF to disappear, if any
     // If output of a presel didn't get consted, chances are V3Param didn't visit properly
-    virtual void visit(AstNodePreSel* nodep, AstNUser*) {}
+    virtual void visit(AstNodePreSel* nodep) {}
 
     // Ignored, can eliminate early
-    virtual void visit(AstSysIgnore* nodep, AstNUser*) {
+    virtual void visit(AstSysIgnore* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst) {
 	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
@@ -1927,7 +1927,7 @@ private:
     }
 
     // Simplify
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->cvtRangeConst();
     }
@@ -1935,12 +1935,12 @@ private:
     //-----
     // Jump elimination
 
-    virtual void visit(AstJumpGo* nodep, AstNUser*) {
+    virtual void visit(AstJumpGo* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doExpensive) { nodep->labelp()->user4(true); }
     }
 
-    virtual void visit(AstJumpLabel* nodep, AstNUser*) {
+    virtual void visit(AstJumpLabel* nodep) {
 	// Because JumpLabels disable many optimizations,
 	// remove JumpLabels that are not pointed to by any AstJumpGos
 	// Note this assumes all AstJumpGos are underneath the given label; V3Broken asserts this
@@ -2269,7 +2269,7 @@ private:
     // Note we can't convert EqCase/NeqCase to Eq/Neq here because that would break 3'b1x1==3'b101
 
     //-----
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	if (m_required) {
 	    if (nodep->castNodeDType() || nodep->castRange()) {
diff --git a/src/V3Coverage.cpp b/src/V3Coverage.cpp
index 8ad8a1bc5..c77363ba3 100644
--- a/src/V3Coverage.cpp
+++ b/src/V3Coverage.cpp
@@ -128,7 +128,7 @@ private:
     }
 
     // VISITORS - BOTH
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_inModOff = nodep->isTop();   // Ignore coverage on top module; it's a shell we created
 	m_fileps.clear();
@@ -138,7 +138,7 @@ private:
     }
 
     // VISITORS - TOGGLE COVERAGE
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	bool oldtog = m_inToggleOff;
 	{
 	    m_inToggleOff = true;
@@ -146,7 +146,7 @@ private:
 	}
 	m_inToggleOff = oldtog;
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_modp && !m_inModOff && !m_inToggleOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageToggle()) {
@@ -279,7 +279,7 @@ private:
     }
 
     // VISITORS - LINE COVERAGE
-    virtual void visit(AstIf* nodep, AstNUser*) { // Note not AstNodeIf; other types don't get covered
+    virtual void visit(AstIf* nodep) { // Note not AstNodeIf; other types don't get covered
 	UINFO(4," IF: "<<nodep<<endl);
 	if (m_checkBlock) {
 	    // An else-if.  When we iterate the if, use "elsif" marking
@@ -312,7 +312,7 @@ private:
 	    m_checkBlock = true;  // Reset as a child may have cleared it
 	}
     }
-    virtual void visit(AstCaseItem* nodep, AstNUser*) {
+    virtual void visit(AstCaseItem* nodep) {
 	UINFO(4," CASEI: "<<nodep<<endl);
 	if (m_checkBlock && !m_inModOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {
@@ -324,7 +324,7 @@ private:
 	    m_checkBlock = true;  // Reset as a child may have cleared it
 	}
     }
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    virtual void visit(AstPslCover* nodep) {
 	UINFO(4," PSLCOVER: "<<nodep<<endl);
 	m_checkBlock = true;  // Always do cover blocks, even if there's a $stop
 	nodep->iterateChildren(*this);
@@ -334,11 +334,11 @@ private:
 	}
 	m_checkBlock = true;  // Reset as a child may have cleared it
     }
-    virtual void visit(AstStop* nodep, AstNUser*) {
+    virtual void visit(AstStop* nodep) {
 	UINFO(4,"  STOP: "<<nodep<<endl);
 	m_checkBlock = false;
     }
-    virtual void visit(AstPragma* nodep, AstNUser*) {
+    virtual void visit(AstPragma* nodep) {
 	if (nodep->pragType() == AstPragmaType::COVERAGE_BLOCK_OFF) {
 	    // Skip all NEXT nodes under this block, and skip this if/case branch
 	    UINFO(4,"  OFF: "<<nodep<<endl);
@@ -348,7 +348,7 @@ private:
 	    if (m_checkBlock) nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	// Record the hierarchy of any named begins, so we can apply to user
 	// coverage points.  This is because there may be cov points inside
 	// generate blocks; each point should get separate consideration.
@@ -368,7 +368,7 @@ private:
     }
 
     // VISITORS - BOTH
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	if (m_checkBlock) {
 	    nodep->iterateChildren(*this);
diff --git a/src/V3CoverageJoin.cpp b/src/V3CoverageJoin.cpp
index c19a0a99b..ff9e64606 100644
--- a/src/V3CoverageJoin.cpp
+++ b/src/V3CoverageJoin.cpp
@@ -103,19 +103,19 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Find all Coverage's
 	nodep->iterateChildren(*this);
 	// Simplify
 	detectDuplicates();
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	m_toggleps.push_back(nodep);
 	nodep->iterateChildren(*this);
     }
     //--------------------
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {}  // Accelerate
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Dead.cpp b/src/V3Dead.cpp
index d77a33d09..2f783c37e 100644
--- a/src/V3Dead.cpp
+++ b/src/V3Dead.cpp
@@ -58,13 +58,13 @@ private:
     // NODE STATE
     // ** Shared with DeadVisitor **
     // VISITORS
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->modp()->user1Inc(-1);
     }
     //-----
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {}  // Accelerate
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -135,18 +135,18 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->scopep()) nodep->scopep()->user1Inc();
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->aboveScopep()) nodep->aboveScopep()->user1Inc();
@@ -155,14 +155,14 @@ private:
 	    m_scopesp.push_back(nodep);
 	}
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	m_cellsp.push_back(nodep);
 	nodep->modp()->user1Inc();
     }
 
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->varScopep()) {
@@ -177,7 +177,7 @@ private:
 	    else nodep->packagep()->user1Inc();
 	}
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->packagep()) {
@@ -185,7 +185,7 @@ private:
 	    else nodep->packagep()->user1Inc();
 	}
     }
-    virtual void visit(AstRefDType* nodep, AstNUser*) {
+    virtual void visit(AstRefDType* nodep) {
 	nodep->iterateChildren(*this);
 	checkDType(nodep);
 	checkAll(nodep);
@@ -194,12 +194,12 @@ private:
 	    else nodep->packagep()->user1Inc();
 	}
     }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeDType* nodep) {
 	nodep->iterateChildren(*this);
 	checkDType(nodep);
 	checkAll(nodep);
     }
-    virtual void visit(AstEnumItemRef* nodep, AstNUser*) {
+    virtual void visit(AstEnumItemRef* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->packagep()) {
@@ -208,7 +208,7 @@ private:
 	}
 	checkAll(nodep);
     }
-    virtual void visit(AstModport* nodep, AstNUser*) {
+    virtual void visit(AstModport* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_elimCells) {
 	    if (!nodep->varsp()) {
@@ -218,7 +218,7 @@ private:
 	}
 	checkAll(nodep);
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstTypedef* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_elimCells && !nodep->attrPublic()) {
 	    pushDeletep(nodep->unlinkFrBack()); VL_DANGLING(nodep);
@@ -229,7 +229,7 @@ private:
 	// Normal modules may disappear, e.g. if they are parameterized then removed
 	if (nodep->attrPublic() && m_modp && m_modp->castPackage()) m_modp->user1Inc();
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->scopep()) nodep->scopep()->user1Inc();
@@ -237,7 +237,7 @@ private:
 	    m_vscsp.push_back(nodep);
 	}
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->isSigPublic() && m_modp && m_modp->castPackage()) m_modp->user1Inc();
@@ -245,7 +245,7 @@ private:
 	    m_varsp.push_back(nodep);
 	}
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	// See if simple assignments to variables may be eliminated because that variable is never used.
 	// Similar code in V3Life
 	m_sideEffect = false;
@@ -264,7 +264,7 @@ private:
     }
 
     //-----
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	if (nodep->isOutputter()) m_sideEffect=true;
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
diff --git a/src/V3Delayed.cpp b/src/V3Delayed.cpp
index da9c86e44..0de9cfdf4 100644
--- a/src/V3Delayed.cpp
+++ b/src/V3Delayed.cpp
@@ -338,22 +338,22 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	//VV*****  We reset all userp() on the netlist
 	m_modVarMap.clear();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	AstNode::user3ClearTree();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	m_cfuncp = nodep;
 	nodep->iterateChildren(*this);
 	m_cfuncp = NULL;
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	m_activep = nodep;
 	bool oldinit = m_inInitial;
 	m_inInitial = nodep->hasInitial();
@@ -361,7 +361,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_inInitial = oldinit;
     }
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	m_inDly = true;
 	m_nextDlyp = nodep->nextp()->castAssignDly();  // Next assignment in same block, maybe NULL.
 	if (m_cfuncp) nodep->v3error("Unsupported: Delayed assignment inside public function/task");
@@ -385,7 +385,7 @@ private:
 	m_nextDlyp = NULL;
     }
 
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (!nodep->user2Inc()) {  // Not done yet
 	    if (m_inDly && nodep->lvalue()) {
 		UINFO(4,"AssignDlyVar: "<<nodep<<endl);
@@ -432,10 +432,10 @@ private:
 	}
     }
 
-    virtual void visit(AstNodeFor* nodep, AstNUser*) {
+    virtual void visit(AstNodeFor* nodep) {
 	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin\n");
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	bool oldloop = m_inLoop;
 	m_inLoop = true;
 	nodep->iterateChildren(*this);
@@ -444,7 +444,7 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Depth.cpp b/src/V3Depth.cpp
index 2e0bc0b4c..610bc7d4e 100644
--- a/src/V3Depth.cpp
+++ b/src/V3Depth.cpp
@@ -85,14 +85,14 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_funcp = NULL;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	m_funcp = nodep;
 	m_depth = 0;
 	m_maxdepth = 0;
@@ -106,13 +106,13 @@ private:
 	nodep->iterateChildren(*this);
 	m_stmtp = NULL;
     }
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	visitStmt(nodep);
     }
     // Operators
-    virtual void visit(AstNodeTermop* nodep, AstNUser*) {
+    virtual void visit(AstNodeTermop* nodep) {
     }
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	// We have some operator defines that use 2 parens, so += 2.
 	m_depth += 2;
 	if (m_depth>m_maxdepth) m_maxdepth=m_depth;
@@ -139,19 +139,19 @@ private:
 	    m_funcp->isStatic(false);
 	}
     }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	needNonStaticFunc(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstUCStmt* nodep, AstNUser*) {
+    virtual void visit(AstUCStmt* nodep) {
 	needNonStaticFunc(nodep);
 	visitStmt(nodep);
     }
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar* nodep, AstNUser*) {}	// Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {}	// Don't hit varrefs under vars
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3DepthBlock.cpp b/src/V3DepthBlock.cpp
index 05821c69f..03766e30f 100644
--- a/src/V3DepthBlock.cpp
+++ b/src/V3DepthBlock.cpp
@@ -76,14 +76,14 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_deepNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	// We recurse into this.
 	int lastDepth = m_depth;
 	AstCFunc* lastFuncp = m_funcp;
@@ -111,15 +111,15 @@ private:
 	}
 	m_depth--;
     }
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	visitStmt(nodep);
     }
 
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
+    virtual void visit(AstNodeMath* nodep) {}  // Accelerate
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar* nodep, AstNUser*) {}	// Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {}	// Don't hit varrefs under vars
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Descope.cpp b/src/V3Descope.cpp
index f80b385b2..0dade0c73 100644
--- a/src/V3Descope.cpp
+++ b/src/V3Descope.cpp
@@ -178,24 +178,24 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_modFuncs.clear();
 	nodep->iterateChildren(*this);
 	makePublicFuncWrappers();
 	m_modp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	m_scopep = nodep;
 	nodep->iterateChildren(*this);
 	m_scopep = NULL;
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	// Delete the varscope when we're finished
 	nodep->unlinkFrBack();
 	pushDeletep(nodep);
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	nodep->iterateChildren(*this);
 	// Convert the hierch name
 	if (!m_scopep) nodep->v3fatalSrc("Node not under scope");
@@ -204,7 +204,7 @@ private:
 	nodep->hierThis(hierThis);
 	nodep->varScopep(NULL);
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	//UINFO(9,"       "<<nodep<<endl);
 	nodep->iterateChildren(*this);
 	// Convert the hierch name
@@ -215,7 +215,7 @@ private:
 	// Can't do this, as we may have more calls later
 	// nodep->funcp()->scopep(NULL);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	if (!nodep->user1()) {
 	    m_needThis = false;
 	    nodep->iterateChildren(*this);
@@ -241,8 +241,8 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstVar*, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3EmitC.cpp b/src/V3EmitC.cpp
index f6020396f..a64f65fbb 100644
--- a/src/V3EmitC.cpp
+++ b/src/V3EmitC.cpp
@@ -132,7 +132,7 @@ public:
     }
 
     // VISITORS
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	bool paren = true;  bool decind = false;
 	if (AstSel* selp=nodep->lhsp()->castSel()) {
 	    if (selp->widthMin()==1) {
@@ -195,9 +195,9 @@ public:
 	if (decind) ofp()->blockDec();
 	if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstAlwaysPublic*, AstNUser*) {
+    virtual void visit(AstAlwaysPublic*) {
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	puts(nodep->hiername());
 	puts(nodep->funcp()->name());
 	puts("(");
@@ -215,15 +215,15 @@ public:
 	    puts(");\n");
 	}
     }
-    virtual void visit(AstNodeCase* nodep, AstNUser*) {
+    virtual void visit(AstNodeCase* nodep) {
 	// In V3Case...
 	nodep->v3fatalSrc("Case statements should have been reduced out\n");
     }
-    virtual void visit(AstComment* nodep, AstNUser*) {
+    virtual void visit(AstComment* nodep) {
 	putsDecoration((string)"// "+nodep->name()+" at "+nodep->fileline()->ascii()+"\n");
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+    virtual void visit(AstCoverDecl* nodep) {
 	puts("__vlCoverInsert(");	// As Declared in emitCoverageDecl
 	puts("&(vlSymsp->__Vcoverage[");
 	puts(cvtToStr(nodep->dataDeclThisp()->binNum())); puts("])");
@@ -241,22 +241,22 @@ public:
 	puts(", ");	putsQuoted(nodep->comment());
 	puts(");\n");
     }
-    virtual void visit(AstCoverInc* nodep, AstNUser*) {
+    virtual void visit(AstCoverInc* nodep) {
 	puts("++(vlSymsp->__Vcoverage[");
 	puts(cvtToStr(nodep->declp()->dataDeclThisp()->binNum()));
 	puts("]);\n");
     }
-    virtual void visit(AstCReturn* nodep, AstNUser*) {
+    virtual void visit(AstCReturn* nodep) {
 	puts("return (");
 	nodep->lhsp()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstDisplay* nodep) {
 	string text = nodep->fmtp()->text();
 	if (nodep->addNewline()) text += "\n";
 	displayNode(nodep, nodep->fmtp()->scopeNamep(), text, nodep->fmtp()->exprsp(), false);
     }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
 	// For use under AstCCalls for dpiImports.  ScopeNames under displays are handled in AstDisplay
 	if (!nodep->dpiExport()) {
 	    // this is where the DPI import context scope is set
@@ -264,19 +264,19 @@ public:
 	    putbs("(&(vlSymsp->__Vscope_"+scope+"))");
 	}
     }
-    virtual void visit(AstSFormat* nodep, AstNUser*) {
+    virtual void visit(AstSFormat* nodep) {
 	displayNode(nodep, nodep->fmtp()->scopeNamep(), nodep->fmtp()->text(), nodep->fmtp()->exprsp(), false);
     }
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	displayNode(nodep, nodep->scopeNamep(), nodep->text(), nodep->exprsp(), false);
     }
-    virtual void visit(AstFScanF* nodep, AstNUser*) {
+    virtual void visit(AstFScanF* nodep) {
 	displayNode(nodep, NULL, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstSScanF* nodep, AstNUser*) {
+    virtual void visit(AstSScanF* nodep) {
 	displayNode(nodep, NULL, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstValuePlusArgs* nodep, AstNUser*) {
+    virtual void visit(AstValuePlusArgs* nodep) {
 	string prefix;
 	char format = '?';
 	bool pct=false;
@@ -327,12 +327,12 @@ public:
 	nodep->exprsp()->iterateAndNext(*this);
 	puts(")");
     }
-    virtual void visit(AstTestPlusArgs* nodep, AstNUser*) {
+    virtual void visit(AstTestPlusArgs* nodep) {
 	puts("VL_TESTPLUSARGS_I(");
 	putsQuoted(nodep->text());
 	puts(")");
     }
-    virtual void visit(AstFGetS* nodep, AstNUser*) {
+    virtual void visit(AstFGetS* nodep) {
 	checkMaxWords(nodep);
 	emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), NULL);
     }
@@ -342,7 +342,7 @@ public:
 	    nodep->v3error("String of "<<nodep->width()<<" bits exceeds hardcoded limit VL_TO_STRING_MAX_WORDS in verilatedos.h");
 	}
     }
-    virtual void visit(AstFOpen* nodep, AstNUser*) {
+    virtual void visit(AstFOpen* nodep) {
 	nodep->filep()->iterateAndNext(*this);
 	puts(" = VL_FOPEN_");
 	emitIQW(nodep->filenamep());
@@ -359,7 +359,7 @@ public:
 	nodep->modep()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstReadMem* nodep, AstNUser*) {
+    virtual void visit(AstReadMem* nodep) {
 	puts("VL_READMEM_");
 	emitIQW(nodep->filenamep());
 	puts(" (");  // We take a void* rather than emitIQW(nodep->memp());
@@ -393,14 +393,14 @@ public:
 	putbs(","); if (nodep->msbp()) { nodep->msbp()->iterateAndNext(*this); } else puts("~0");
 	puts(");\n");
     }
-    virtual void visit(AstFClose* nodep, AstNUser*) {
+    virtual void visit(AstFClose* nodep) {
 	puts("VL_FCLOSE_I(");
 	nodep->filep()->iterateAndNext(*this);
 	puts("); ");
 	nodep->filep()->iterateAndNext(*this);	// For saftey, so user doesn't later WRITE with it.
 	puts("=0;\n");
     }
-    virtual void visit(AstFFlush* nodep, AstNUser*) {
+    virtual void visit(AstFFlush* nodep) {
 	if (!nodep->filep()) {
 	    puts("fflush (stdout);\n");
 	} else {
@@ -411,7 +411,7 @@ public:
 	    puts(")); }\n");
 	}
     }
-    virtual void visit(AstSystemT* nodep, AstNUser*) {
+    virtual void visit(AstSystemT* nodep) {
 	puts("(void)VL_SYSTEM_I");
 	emitIQW(nodep->lhsp());
 	puts("(");
@@ -423,7 +423,7 @@ public:
 	nodep->lhsp()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstSystemF* nodep, AstNUser*) {
+    virtual void visit(AstSystemF* nodep) {
 	puts("VL_SYSTEM_I");
 	emitIQW(nodep->lhsp());
 	puts("(");
@@ -435,16 +435,16 @@ public:
 	nodep->lhsp()->iterateAndNext(*this);
 	puts(")");
     }
-    virtual void visit(AstJumpGo* nodep, AstNUser*) {
+    virtual void visit(AstJumpGo* nodep) {
 	puts("goto __Vlabel"+cvtToStr(nodep->labelp()->labelNum())+";\n");
     }
-    virtual void visit(AstJumpLabel* nodep, AstNUser*) {
+    virtual void visit(AstJumpLabel* nodep) {
 	puts("{\n");
 	nodep->stmtsp()->iterateAndNext(*this);
 	puts("}\n");
 	puts("__Vlabel"+cvtToStr(nodep->labelNum())+": ;\n");
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	nodep->precondsp()->iterateAndNext(*this);
 	puts("while (");
 	nodep->condp()->iterateAndNext(*this);
@@ -454,7 +454,7 @@ public:
 	nodep->precondsp()->iterateAndNext(*this);  // Need to recompute before next loop
 	puts("}\n");
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	puts("if (");
 	if (nodep->branchPred() != AstBranchPred::BP_UNKNOWN) {
 	    puts(nodep->branchPred().ascii()); puts("(");
@@ -469,41 +469,41 @@ public:
 	}
 	puts("}\n");
     }
-    virtual void visit(AstStop* nodep, AstNUser*) {
+    virtual void visit(AstStop* nodep) {
 	puts("vl_stop(");
 	putsQuoted(nodep->fileline()->filename());
 	puts(",");
 	puts(cvtToStr(nodep->fileline()->lineno()));
 	puts(",\"\");\n");
     }
-    virtual void visit(AstFinish* nodep, AstNUser*) {
+    virtual void visit(AstFinish* nodep) {
 	puts("vl_finish(");
 	putsQuoted(nodep->fileline()->filename());
 	puts(",");
 	puts(cvtToStr(nodep->fileline()->lineno()));
 	puts(",\"\");\n");
     }
-    virtual void visit(AstText* nodep, AstNUser*) {
+    virtual void visit(AstText* nodep) {
 	if (nodep->tracking()) {
 	    puts(nodep->text());
 	} else {
 	    ofp()->putsNoTracking(nodep->text());
 	}
     }
-    virtual void visit(AstCStmt* nodep, AstNUser*) {
+    virtual void visit(AstCStmt* nodep) {
 	putbs("");
 	nodep->bodysp()->iterateAndNext(*this);
     }
-    virtual void visit(AstCMath* nodep, AstNUser*) {
+    virtual void visit(AstCMath* nodep) {
 	putbs("");
 	nodep->bodysp()->iterateAndNext(*this);
     }
-    virtual void visit(AstUCStmt* nodep, AstNUser*) {
+    virtual void visit(AstUCStmt* nodep) {
 	putsDecoration("// $c statement at "+nodep->fileline()->ascii()+"\n");
 	nodep->bodysp()->iterateAndNext(*this);
 	puts("\n");
     }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	puts("\n");
 	putsDecoration("// $c function at "+nodep->fileline()->ascii()+"\n");
 	nodep->bodysp()->iterateAndNext(*this);
@@ -511,10 +511,10 @@ public:
     }
 
     // Operators
-    virtual void visit(AstNodeTermop* nodep, AstNUser*) {
+    virtual void visit(AstNodeTermop* nodep) {
 	emitOpName(nodep, nodep->emitC(), NULL, NULL, NULL);
     }
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	if (emitSimpleOk(nodep)) {
 	    putbs("("); puts(nodep->emitSimpleOperator()); puts(" ");
 	    nodep->lhsp()->iterateAndNext(*this); puts(")");
@@ -522,7 +522,7 @@ public:
 	    emitOpName(nodep, nodep->emitC(), nodep->lhsp(), NULL, NULL);
 	}
     }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	if (emitSimpleOk(nodep)) {
 	    putbs("("); nodep->lhsp()->iterateAndNext(*this);
 	    puts(" "); putbs(nodep->emitSimpleOperator()); puts(" ");
@@ -531,9 +531,9 @@ public:
 	    emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), NULL);
 	}
     }
-    virtual void visit(AstRedXor* nodep, AstNUser* vup) {
+    virtual void visit(AstRedXor* nodep) {
 	if (nodep->lhsp()->isWide()) {
-	    visit(nodep->castNodeUniop(), vup);
+	    visit(nodep->castNodeUniop());
 	} else {
 	    putbs("VL_REDXOR_");
 	    puts(cvtToStr(nodep->lhsp()->dtypep()->widthPow2()));
@@ -542,13 +542,13 @@ public:
 	    puts(")");
 	}
     }
-    virtual void visit(AstMulS* nodep, AstNUser* vup) {
+    virtual void visit(AstMulS* nodep) {
 	if (nodep->widthWords() > VL_MULS_MAX_WORDS) {
 	    nodep->v3error("Unsupported: Signed multiply of "<<nodep->width()<<" bits exceeds hardcoded limit VL_MULS_MAX_WORDS in verilatedos.h");
 	}
-	visit(nodep->castNodeBiop(), vup);
+	visit(nodep->castNodeBiop());
     }
-    virtual void visit(AstCCast* nodep, AstNUser*) {
+    virtual void visit(AstCCast* nodep) {
 	// Extending a value of the same word width is just a NOP.
 	if (nodep->size()>VL_WORDSIZE) {
 	    puts("(QData)(");
@@ -558,7 +558,7 @@ public:
 	nodep->lhsp()->iterateAndNext(*this);
 	puts(")");
     }
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	// Widths match up already, so we'll just use C++'s operator w/o any temps.
 	if (nodep->expr1p()->isWide()) {
 	    emitOpName(nodep, nodep->emitC(), nodep->condp(), nodep->expr1p(), nodep->expr2p());
@@ -569,11 +569,11 @@ public:
 	    nodep->expr2p()->iterateAndNext(*this); puts(")");
 	}
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	// Note ASSIGN checks for this on a LHS
 	emitOpName(nodep, nodep->emitC(), nodep->fromp(), nodep->lsbp(), nodep->thsp());
     }
-    virtual void visit(AstReplicate* nodep, AstNUser*) {
+    virtual void visit(AstReplicate* nodep) {
 	if (nodep->lhsp()->widthMin() == 1 && !nodep->isWide()) {
 	    if (((int)nodep->rhsp()->castConst()->toUInt()
 		     * nodep->lhsp()->widthMin()) != nodep->widthMin())
@@ -591,7 +591,7 @@ public:
 	    emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), NULL);
 	}
     }
-    virtual void visit(AstStreamL* nodep, AstNUser*) {
+    virtual void visit(AstStreamL* nodep) {
 	// Attempt to use a "fast" stream function for slice size = power of 2
 	if (!nodep->isWide()) {
 	    uint32_t isPow2 = nodep->rhsp()->castConst()->num().countOnes() == 1;
@@ -614,7 +614,7 @@ public:
 	emitOpName(nodep, "VL_STREAML_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)", nodep->lhsp(), nodep->rhsp(), NULL);
     }
     // Terminals
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	puts(nodep->hiername());
 	puts(nodep->varp()->name());
     }
@@ -677,7 +677,7 @@ public:
 	emitConstant(constp, NULL, assignString);
 	puts(";\n");
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	if (nodep->isWide()) {
 	    if (!m_wideTempRefp) nodep->v3fatalSrc("Wide Constant w/ no temp");
 	    emitConstant(nodep, m_wideTempRefp, "");
@@ -688,26 +688,26 @@ public:
     }
 
     // Just iterate
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	nodep->iterateChildren(*this);
     }
     // NOPs
-    virtual void visit(AstTypedef*, AstNUser*) {}
-    virtual void visit(AstPragma*, AstNUser*) {}
-    virtual void visit(AstCell*, AstNUser*) {}		// Handled outside the Visit class
-    virtual void visit(AstVar*, AstNUser*) {}		// Handled outside the Visit class
-    virtual void visit(AstNodeText*, AstNUser*) {}	// Handled outside the Visit class
-    virtual void visit(AstTraceDecl*, AstNUser*) {}	// Handled outside the Visit class
-    virtual void visit(AstTraceInc*, AstNUser*) {}	// Handled outside the Visit class
-    virtual void visit(AstCFile*, AstNUser*) {}		// Handled outside the Visit class
+    virtual void visit(AstTypedef*) {}
+    virtual void visit(AstPragma*) {}
+    virtual void visit(AstCell*) {}		// Handled outside the Visit class
+    virtual void visit(AstVar*) {}		// Handled outside the Visit class
+    virtual void visit(AstNodeText*) {}	// Handled outside the Visit class
+    virtual void visit(AstTraceDecl*) {}	// Handled outside the Visit class
+    virtual void visit(AstTraceInc*) {}	// Handled outside the Visit class
+    virtual void visit(AstCFile*) {}		// Handled outside the Visit class
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	puts((string)"\n???? // "+nodep->prettyTypeName()+"\n");
 	nodep->iterateChildren(*this);
 	nodep->v3fatalSrc("Unknown node type reached emitter: "<<nodep->prettyTypeName());
@@ -821,7 +821,7 @@ class EmitCImp : EmitCStmts {
     //---------------------------------------
     // VISITORS
     using EmitCStmts::visit;  // Suppress hidden overloaded virtual function warnng
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	// TRACE_* and DPI handled elsewhere
 	if (nodep->funcType().isTrace()) return;
 	if (nodep->dpiImport()) return;
@@ -908,11 +908,11 @@ class EmitCImp : EmitCStmts {
 	}
     }
 
-    virtual void visit(AstChangeDet* nodep, AstNUser*) {
+    virtual void visit(AstChangeDet* nodep) {
 	m_blkChangeDetVec.push_back(nodep);
     }
 
-    virtual void visit(AstCReset* nodep, AstNUser*) {
+    virtual void visit(AstCReset* nodep) {
 	AstVar* varp = nodep->varrefp()->varp();
 	emitVarReset(varp);
     }
@@ -2357,14 +2357,14 @@ class EmitCTrace : EmitCStmts {
 
     // VISITORS
     using EmitCStmts::visit;  // Suppress hidden overloaded virtual function warnng
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Top module only
 	nodep->topModulep()->accept(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	if (nodep->slow() != m_slow) return;
 	if (nodep->funcType().isTrace()) {   // TRACE_*
 	    m_funcp = nodep;
@@ -2411,7 +2411,7 @@ class EmitCTrace : EmitCStmts {
 	}
 	m_funcp = NULL;
     }
-    virtual void visit(AstTraceDecl* nodep, AstNUser*) {
+    virtual void visit(AstTraceDecl* nodep) {
 	if (nodep->arrayRange().ranged()) {
 	    puts("{int i; for (i=0; i<"+cvtToStr(nodep->arrayRange().elements())+"; i++) {\n");
 	    emitTraceInitOne(nodep);
@@ -2421,7 +2421,7 @@ class EmitCTrace : EmitCStmts {
 	    puts("\n");
 	}
     }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) {
+    virtual void visit(AstTraceInc* nodep) {
 	if (nodep->declp()->arrayRange().ranged()) {
 	    // It traces faster if we unroll the loop
 	    for (int i=0; i<nodep->declp()->arrayRange().elements(); i++) {
@@ -2431,9 +2431,9 @@ class EmitCTrace : EmitCStmts {
 	    emitTraceChangeOne(nodep, -1);
 	}
     }
-    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+    virtual void visit(AstCoverDecl* nodep) {
     }
-    virtual void visit(AstCoverInc* nodep, AstNUser*) {
+    virtual void visit(AstCoverInc* nodep) {
     }
 
 public:
diff --git a/src/V3EmitCBase.h b/src/V3EmitCBase.h
index b18cb063f..b7fc885dd 100644
--- a/src/V3EmitCBase.h
+++ b/src/V3EmitCBase.h
@@ -101,7 +101,7 @@ private:
     // STATE
     int			m_count;	// Number of statements
     // VISITORS
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	m_count++;
 	nodep->iterateChildren(*this);
     }
diff --git a/src/V3EmitCInlines.cpp b/src/V3EmitCInlines.cpp
index 6bc48e8f5..fe202c9ae 100644
--- a/src/V3EmitCInlines.cpp
+++ b/src/V3EmitCInlines.cpp
@@ -44,7 +44,7 @@ class EmitCInlines : EmitCBaseVisitor {
     void emitInt();
 
     // VISITORS
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	// All wide constants load into variables, so we can just hunt for them
 	nodep->iterateChildren(*this);
 	int words = nodep->widthWords();
@@ -56,16 +56,16 @@ class EmitCInlines : EmitCBaseVisitor {
 	    v3Global.needHInlines(true);
 	}
     }
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	if (nodep->keyword() == AstBasicDTypeKwd::STRING) {
 	    v3Global.needHeavy(true);  // #include <string> via verilated_heavy.h when we create symbol file
 	}
     }
 
     // NOPs
-    virtual void visit(AstNodeStmt*, AstNUser*) {}
+    virtual void visit(AstNodeStmt*) {}
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
     //---------------------------------------
diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp
index 09fada420..cd9dd41fb 100644
--- a/src/V3EmitCSyms.cpp
+++ b/src/V3EmitCSyms.cpp
@@ -163,7 +163,7 @@ class EmitCSyms : EmitCBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Collect list of scopes
 	nodep->iterateChildren(*this);
 	varsExpand();
@@ -180,18 +180,18 @@ class EmitCSyms : EmitCBaseVisitor {
 	    emitDpiImp();
 	}
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	nameCheck(nodep);
 	m_modp = nodep;
 	m_labelNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	nameCheck(nodep);
 	m_scopes.push_back(make_pair(nodep, m_modp));
     }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
 	string name = nodep->scopeSymName();
 	//UINFO(9,"scnameins sp "<<nodep->name()<<" sp "<<nodep->scopePrettySymName()<<" ss "<<name<<endl);
 	if (m_scopeNames.find(name) == m_scopeNames.end()) {
@@ -207,7 +207,7 @@ class EmitCSyms : EmitCBaseVisitor {
 	    }
 	}
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nameCheck(nodep);
 	nodep->iterateChildren(*this);
 	if (nodep->isSigUserRdPublic()
@@ -215,17 +215,17 @@ class EmitCSyms : EmitCBaseVisitor {
 	    m_modVars.push_back(make_pair(m_modp, nodep));
 	}
     }
-    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+    virtual void visit(AstCoverDecl* nodep) {
 	// Assign numbers to all bins, so we know how big of an array to use
 	if (!nodep->dataDeclNullp()) {  // else duplicate we don't need code for
 	    nodep->binNum(m_coverBins++);
 	}
     }
-    virtual void visit(AstJumpLabel* nodep, AstNUser*) {
+    virtual void visit(AstJumpLabel* nodep) {
 	nodep->labelNum(++m_labelNum);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	nameCheck(nodep);
 	if (nodep->dpiImport() || nodep->dpiExportWrapper()) {
 	    m_dpis.push_back(nodep);
@@ -235,9 +235,9 @@ class EmitCSyms : EmitCBaseVisitor {
 	m_funcp = NULL;
     }
     // NOPs
-    virtual void visit(AstConst*, AstNUser*) {}
+    virtual void visit(AstConst*) {}
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nameCheck(nodep);
 	nodep->iterateChildren(*this);
     }
diff --git a/src/V3EmitMk.cpp b/src/V3EmitMk.cpp
index 1e1039f95..b798e620f 100644
--- a/src/V3EmitMk.cpp
+++ b/src/V3EmitMk.cpp
@@ -229,7 +229,7 @@ public:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->v3fatalSrc("No visitors implemented.");
     }
 
diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp
index 1cfc8121f..b26591a26 100644
--- a/src/V3EmitV.cpp
+++ b/src/V3EmitV.cpp
@@ -62,15 +62,15 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	putfs(nodep, nodep->verilogKwd()+" "+modClassName(nodep)+";\n");
 	nodep->iterateChildren(*this);
 	putqs(nodep, "end"+nodep->verilogKwd()+"\n");
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	putfs(nodep, nodep->isFunction() ? "function":"task");
 	puts(" ");
 	puts(nodep->prettyName());
@@ -80,7 +80,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	putqs(nodep, "end\n");
     }
 
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	if (nodep->unnamed()) {
 	    putbs("begin\n");
 	} else {
@@ -89,22 +89,22 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	nodep->iterateChildren(*this);
 	puts("end\n");
     }
-    virtual void visit(AstGenerate* nodep, AstNUser*) {
+    virtual void visit(AstGenerate* nodep) {
 	putfs(nodep, "generate\n");
 	nodep->iterateChildren(*this);
 	putqs(nodep, "end\n");
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	putfs(nodep, "final begin\n");
 	nodep->iterateChildren(*this);
 	putqs(nodep, "end\n");
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	putfs(nodep,"initial begin\n");
 	nodep->iterateChildren(*this);
 	putqs(nodep, "end\n");
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	putfs(nodep,"always ");
 	if (m_sensesp) m_sensesp->iterateAndNext(*this);  // In active
 	else nodep->sensesp()->iterateAndNext(*this);
@@ -112,7 +112,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	nodep->bodysp()->iterateAndNext(*this);
 	putqs(nodep,"end\n");
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	putfs(nodep,"/*verilator public_flat_rw ");
 	if (m_sensesp) m_sensesp->iterateAndNext(*this);  // In active
 	else nodep->sensesp()->iterateAndNext(*this);
@@ -120,37 +120,37 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	nodep->bodysp()->iterateAndNext(*this);
 	putqs(nodep,"*/\n");
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	nodep->lhsp()->iterateAndNext(*this);
 	putfs(nodep," "+nodep->verilogKwd()+" ");
 	nodep->rhsp()->iterateAndNext(*this);
 	if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	nodep->lhsp()->iterateAndNext(*this);
 	putfs(nodep," <= ");
 	nodep->rhsp()->iterateAndNext(*this);
 	puts(";\n");
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	putbs("alias ");
 	nodep->lhsp()->iterateAndNext(*this);
 	putfs(nodep," = ");
 	nodep->rhsp()->iterateAndNext(*this);
 	if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	putfs(nodep,"assign ");
 	nodep->lhsp()->iterateAndNext(*this);
 	putbs(" = ");
 	nodep->rhsp()->iterateAndNext(*this);
 	if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstBreak* nodep, AstNUser*) {
+    virtual void visit(AstBreak* nodep) {
 	putbs("break");
 	if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	// AstSenItem is called for dumping in isolation by V3Order
 	putfs(nodep,"@(");
 	for (AstNode* expp=nodep->sensesp(); expp; expp = expp->nextp()) {
@@ -159,16 +159,16 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	}
 	puts(")");
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->sensesp(), nodep->rhsp());
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	putfs(nodep,"");
 	puts(nodep->edgeType().verilogKwd());
 	if (nodep->sensp()) puts(" ");
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeCase* nodep, AstNUser*) {
+    virtual void visit(AstNodeCase* nodep) {
 	putfs(nodep,"");
 	if (AstCase* casep = nodep->castCase()) {
 	    if (casep->priorityPragma()) puts("priority ");
@@ -189,7 +189,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	nodep->itemsp()->iterateAndNext(*this);
 	putqs(nodep,"endcase\n");
     }
-    virtual void visit(AstCaseItem* nodep, AstNUser*) {
+    virtual void visit(AstCaseItem* nodep) {
 	if (nodep->condsp()) {
 	    nodep->condsp()->iterateAndNext(*this);
 	} else putbs("default");
@@ -197,17 +197,17 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	nodep->bodysp()->iterateAndNext(*this);
 	putqs(nodep,"end\n");
     }
-    virtual void visit(AstComment* nodep, AstNUser*) {
+    virtual void visit(AstComment* nodep) {
 	puts((string)"// "+nodep->name()+"\n");
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstContinue* nodep, AstNUser*) {
+    virtual void visit(AstContinue* nodep) {
 	putbs("continue");
 	if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstCoverDecl*, AstNUser*) {}  // N/A
-    virtual void visit(AstCoverInc*, AstNUser*) {}  // N/A
-    virtual void visit(AstCoverToggle*, AstNUser*) {}  // N/A
+    virtual void visit(AstCoverDecl*) {}  // N/A
+    virtual void visit(AstCoverInc*) {}  // N/A
+    virtual void visit(AstCoverToggle*) {}  // N/A
 
     void visitNodeDisplay(AstNode* nodep, AstNode* fileOrStrgp, const string& text, AstNode* exprsp) {
 	putfs(nodep,nodep->verilogKwd());
@@ -220,29 +220,29 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	}
 	puts(");\n");
     }
-    virtual void visit(AstDisable* nodep, AstNUser*) {
+    virtual void visit(AstDisable* nodep) {
 	putbs("disable "+nodep->name()+";\n");
     }
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstDisplay* nodep) {
 	visitNodeDisplay(nodep, nodep->filep(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
     }
-    virtual void visit(AstFScanF* nodep, AstNUser*) {
+    virtual void visit(AstFScanF* nodep) {
 	visitNodeDisplay(nodep, nodep->filep(), nodep->text(), nodep->exprsp());
     }
-    virtual void visit(AstSScanF* nodep, AstNUser*) {
+    virtual void visit(AstSScanF* nodep) {
 	visitNodeDisplay(nodep, nodep->fromp(), nodep->text(), nodep->exprsp());
     }
-    virtual void visit(AstSFormat* nodep, AstNUser*) {
+    virtual void visit(AstSFormat* nodep) {
 	visitNodeDisplay(nodep, nodep->lhsp(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
     }
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	visitNodeDisplay(nodep, NULL, nodep->text(), nodep->exprsp());
     }
-    virtual void visit(AstValuePlusArgs* nodep, AstNUser*) {
+    virtual void visit(AstValuePlusArgs* nodep) {
 	visitNodeDisplay(nodep, NULL, nodep->text(), nodep->exprsp());
     }
 
-    virtual void visit(AstFOpen* nodep, AstNUser*) {
+    virtual void visit(AstFOpen* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
 	if (nodep->filep()) nodep->filep()->iterateAndNext(*this);
@@ -252,27 +252,27 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	if (nodep->modep()) nodep->modep()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstFClose* nodep, AstNUser*) {
+    virtual void visit(AstFClose* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
 	if (nodep->filep()) nodep->filep()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstFFlush* nodep, AstNUser*) {
+    virtual void visit(AstFFlush* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
 	if (nodep->filep()) nodep->filep()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstJumpGo* nodep, AstNUser*) {
+    virtual void visit(AstJumpGo* nodep) {
 	putbs("disable "+cvtToStr((void*)(nodep->labelp()))+";\n");
     }
-    virtual void visit(AstJumpLabel* nodep, AstNUser*) {
+    virtual void visit(AstJumpLabel* nodep) {
 	putbs("begin : "+cvtToStr((void*)(nodep))+"\n");
 	if (nodep->stmtsp()) nodep->stmtsp()->iterateAndNext(*this);
 	puts("end\n");
     }
-    virtual void visit(AstReadMem* nodep, AstNUser*) {
+    virtual void visit(AstReadMem* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
 	if (nodep->filenamep()) nodep->filenamep()->iterateAndNext(*this);
@@ -282,13 +282,13 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	if (nodep->msbp()) { putbs(","); nodep->msbp()->iterateAndNext(*this); }
 	puts(");\n");
     }
-    virtual void visit(AstSysIgnore* nodep, AstNUser*) {
+    virtual void visit(AstSysIgnore* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
 	nodep->exprsp()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstNodeFor* nodep, AstNUser*) {
+    virtual void visit(AstNodeFor* nodep) {
 	putfs(nodep,"for (");
 	m_suppressSemi = true;
 	nodep->initsp()->iterateAndNext(*this);
@@ -301,14 +301,14 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	nodep->bodysp()->iterateAndNext(*this);
 	putqs(nodep,"end\n");
     }
-    virtual void visit(AstRepeat* nodep, AstNUser*) {
+    virtual void visit(AstRepeat* nodep) {
 	putfs(nodep,"repeat (");
 	nodep->countp()->iterateAndNext(*this);
 	puts(") begin\n");
 	nodep->bodysp()->iterateAndNext(*this);
 	putfs(nodep,"end\n");
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	nodep->precondsp()->iterateAndNext(*this);
 	putfs(nodep,"while (");
 	nodep->condp()->iterateAndNext(*this);
@@ -318,7 +318,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	nodep->precondsp()->iterateAndNext(*this);  // Need to recompute before next loop
 	putfs(nodep,"end\n");
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	putfs(nodep,"");
 	if (AstIf* ifp = nodep->castIf()) {
 	    if (ifp->priorityPragma()) puts("priority ");
@@ -336,38 +336,38 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	}
 	putqs(nodep,"end\n");
     }
-    virtual void visit(AstReturn* nodep, AstNUser*) {
+    virtual void visit(AstReturn* nodep) {
 	putfs(nodep,"return ");
 	nodep->lhsp()->iterateAndNext(*this);
 	puts(";\n");
     }
-    virtual void visit(AstStop* nodep, AstNUser*) {
+    virtual void visit(AstStop* nodep) {
 	putfs(nodep,"$stop;\n");
     }
-    virtual void visit(AstFinish* nodep, AstNUser*) {
+    virtual void visit(AstFinish* nodep) {
 	putfs(nodep,"$finish;\n");
     }
-    virtual void visit(AstText* nodep, AstNUser*) {
+    virtual void visit(AstText* nodep) {
 	putsNoTracking(nodep->text());
     }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
     }
-    virtual void visit(AstCStmt* nodep, AstNUser*) {
+    virtual void visit(AstCStmt* nodep) {
 	putfs(nodep,"$_CSTMT(");
 	nodep->bodysp()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstCMath* nodep, AstNUser*) {
+    virtual void visit(AstCMath* nodep) {
 	putfs(nodep,"$_CMATH(");
 	nodep->bodysp()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstUCStmt* nodep, AstNUser*) {
+    virtual void visit(AstUCStmt* nodep) {
 	putfs(nodep,"$c(");
 	nodep->bodysp()->iterateAndNext(*this);
 	puts(");\n");
     }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	putfs(nodep,"$c(");
 	nodep->bodysp()->iterateAndNext(*this);
 	puts(")");
@@ -425,19 +425,19 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
         }
     }
 
-    virtual void visit(AstNodeTermop* nodep, AstNUser*) {
+    virtual void visit(AstNodeTermop* nodep) {
 	emitVerilogFormat(nodep, nodep->emitVerilog());
     }
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp());
     }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp());
     }
-    virtual void visit(AstNodeTriop* nodep, AstNUser*) {
+    virtual void visit(AstNodeTriop* nodep) {
 	emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp(), nodep->thsp());
     }
-    virtual void visit(AstAttrOf* nodep, AstNUser*) {
+    virtual void visit(AstAttrOf* nodep) {
 	putfs(nodep,"$_ATTROF(");
 	nodep->fromp()->iterateAndNext(*this);
 	if (nodep->dimp()) {
@@ -446,7 +446,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	}
 	puts(")");
     }
-    virtual void visit(AstInitArray* nodep, AstNUser*) {
+    virtual void visit(AstInitArray* nodep) {
 	putfs(nodep,"`{");
 	int pos = 0;
 	for (AstNode* itemp = nodep->initsp(); itemp; ++pos, itemp=itemp->nextp()) {
@@ -458,13 +458,13 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	}
 	puts("}");
     }
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	putbs("(");
 	nodep->condp()->iterateAndNext(*this); putfs(nodep," ? ");
 	nodep->expr1p()->iterateAndNext(*this); putbs(" : ");
 	nodep->expr2p()->iterateAndNext(*this); puts(")");
     }
-    virtual void visit(AstRange* nodep, AstNUser*) {
+    virtual void visit(AstRange* nodep) {
 	puts("[");
 	if (nodep->msbp()->castConst() && nodep->lsbp()->castConst()) {
 	    // Looks nicer if we print [1:0] rather than [32'sh1:32sh0]
@@ -475,7 +475,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	    nodep->rightp()->iterateAndNext(*this); puts("]");
 	}
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	nodep->fromp()->iterateAndNext(*this); puts("[");
 	if (nodep->lsbp()->castConst()) {
 	    if (nodep->widthp()->isOne()) {
@@ -497,51 +497,51 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	}
 	puts("]");
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstTypedef* nodep) {
 	putfs(nodep,"typedef ");
 	nodep->dtypep()->iterateAndNext(*this); puts(" ");
 	puts(nodep->prettyName());
 	puts(";\n");
     }
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	if (nodep->isSigned()) putfs(nodep,"signed ");
 	putfs(nodep,nodep->prettyName());
 	if (nodep->rangep()) { puts(" "); nodep->rangep()->iterateAndNext(*this); puts(" "); }
 	else if (nodep->isRanged()) { puts(" ["); puts(cvtToStr(nodep->msb())); puts(":0] "); }
     }
-    virtual void visit(AstConstDType* nodep, AstNUser*) {
+    virtual void visit(AstConstDType* nodep) {
 	putfs(nodep,"const ");
 	nodep->subDTypep()->accept(*this);
     }
-    virtual void visit(AstNodeArrayDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeArrayDType* nodep) {
 	nodep->subDTypep()->accept(*this);
 	nodep->rangep()->iterateAndNext(*this);
     }
-    virtual void visit(AstNodeClassDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeClassDType* nodep) {
 	puts(nodep->verilogKwd()+" ");
 	if (nodep->packed()) puts("packed ");
 	puts("\n");
 	nodep->membersp()->iterateAndNext(*this);
 	puts("}");
     }
-    virtual void visit(AstMemberDType* nodep, AstNUser*) {
+    virtual void visit(AstMemberDType* nodep) {
 	nodep->subDTypep()->accept(*this);
 	puts(" ");
 	puts(nodep->name());
 	puts("}");
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	if (nodep->dotted()!="") { putfs(nodep,nodep->dotted()); puts("."); puts(nodep->prettyName()); }
 	else { putfs(nodep,nodep->prettyName()); }
 	puts("(");
 	nodep->pinsp()->iterateAndNext(*this);
 	puts(")");
     }
-    virtual void visit(AstArg* nodep, AstNUser*) {
+    virtual void visit(AstArg* nodep) {
 	nodep->exprp()->iterateAndNext(*this);
     }
     // Terminals
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varScopep())
 	    putfs(nodep,nodep->varScopep()->prettyName());
 	else {
@@ -549,43 +549,43 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	    puts(nodep->varp()->prettyName());
 	}
     }
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	putfs(nodep,nodep->dotted());
 	puts(".");
 	puts(nodep->varp()->prettyName());
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	putfs(nodep,nodep->num().ascii(true,true));
     }
 
     // Just iterate
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	puts(" ");
 	nodep->dtypep()->iterate(*this); puts(" ");
 	puts(nodep->prettyName());
 	puts(";\n");
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	m_sensesp = nodep->sensesp();
 	nodep->stmtsp()->iterateAndNext(*this);
 	m_sensesp = NULL;
     }
-    virtual void visit(AstVarScope*, AstNUser*) {}
-    virtual void visit(AstNodeText*, AstNUser*) {}
-    virtual void visit(AstTraceDecl*, AstNUser*) {}
-    virtual void visit(AstTraceInc*, AstNUser*) {}
+    virtual void visit(AstVarScope*) {}
+    virtual void visit(AstNodeText*) {}
+    virtual void visit(AstTraceDecl*) {}
+    virtual void visit(AstTraceInc*) {}
     // NOPs
-    virtual void visit(AstPragma*, AstNUser*) {}
-    virtual void visit(AstCell*, AstNUser*) {}		// Handled outside the Visit class
+    virtual void visit(AstPragma*) {}
+    virtual void visit(AstCell*) {}		// Handled outside the Visit class
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	puts((string)"\n???? // "+nodep->prettyTypeName()+"\n");
 	nodep->iterateChildren(*this);
 	// Not v3fatalSrc so we keep processing
diff --git a/src/V3EmitXml.cpp b/src/V3EmitXml.cpp
index 2519edd78..e7fcd07a6 100644
--- a/src/V3EmitXml.cpp
+++ b/src/V3EmitXml.cpp
@@ -81,23 +81,23 @@ class EmitXmlFileVisitor : public AstNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	puts("<netlist>\n");
 	nodep->iterateChildren(*this);
 	puts("</netlist>\n");
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	outputTag(nodep, "");
 	if (nodep->level()==1 || nodep->level()==2) // ==2 because we don't add wrapper when in XML mode
 	    puts(" topModule=\"1\"");  // IEEE vpiTopModule
 	outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	outputTag(nodep, "instance");	// IEEE: vpiInstance
 	puts(" defName="); putsQuoted(nodep->modName());  // IEEE vpiDefName
 	outputChildrenEnd(nodep, "instance");
     }
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	// What we call a pin in verilator is a port in the IEEE spec.
 	outputTag(nodep, "port");	// IEEE: vpiPort
 	if (nodep->modVarp()->isInOnly())
@@ -109,13 +109,13 @@ class EmitXmlFileVisitor : public AstNVisitor {
 	// Children includes vpiHighConn and vpiLowConn; we don't support port bits (yet?)
 	outputChildrenEnd(nodep, "port");
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	outputTag(nodep, "contAssign");	// IEEE: vpiContAssign
 	outputChildrenEnd(nodep, "contAssign");
     }
 
     // Data types
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	outputTag(nodep, "basicDType ");
 	if (nodep->isRanged()) {
 	    puts(" left=\""+cvtToStr(nodep->left())+"\"");
@@ -125,7 +125,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
     }
 
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	outputTag(nodep, "");
 	outputChildrenEnd(nodep, "");
     }
diff --git a/src/V3Expand.cpp b/src/V3Expand.cpp
index 37d5c441a..c7cb9eb91 100644
--- a/src/V3Expand.cpp
+++ b/src/V3Expand.cpp
@@ -308,7 +308,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstExtend* nodep, AstNUser*) {
+    virtual void visit(AstExtend* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	if (nodep->isWide()) {
@@ -347,7 +347,7 @@ private:
 	return true;
     }
 
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	// Remember, Sel's may have non-integer rhs, so need to optimize for that!
@@ -648,7 +648,7 @@ private:
 	}
     }
 
-    virtual void visit(AstConcat* nodep, AstNUser*) {
+    virtual void visit(AstConcat* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	if (nodep->isWide()) {
@@ -688,7 +688,7 @@ private:
 	return true;
     }
 
-    virtual void visit(AstReplicate* nodep, AstNUser*) {
+    virtual void visit(AstReplicate* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	if (nodep->isWide()) {
@@ -749,7 +749,7 @@ private:
 	return true;
     }
 
-    virtual void visit(AstChangeXor* nodep, AstNUser*) {
+    virtual void visit(AstChangeXor* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	UINFO(8,"    Wordize ChangeXor "<<nodep<<endl);
@@ -787,10 +787,10 @@ private:
 	    replaceWithDelete(nodep,newp); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstEq* nodep, AstNUser*) { visitEqNeq (nodep); }
-    virtual void visit(AstNeq* nodep, AstNUser*) { visitEqNeq (nodep); }
+    virtual void visit(AstEq* nodep) { visitEqNeq (nodep); }
+    virtual void visit(AstNeq* nodep) { visitEqNeq (nodep); }
 
-    virtual void visit(AstRedOr* nodep, AstNUser*) {
+    virtual void visit(AstRedOr* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	if (nodep->lhsp()->isWide()) {
@@ -814,7 +814,7 @@ private:
 	    replaceWithDelete(nodep,newp); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstRedAnd* nodep, AstNUser*) {
+    virtual void visit(AstRedAnd* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	if (nodep->lhsp()->isWide()) {
@@ -843,7 +843,7 @@ private:
 	    replaceWithDelete(nodep,newp); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstRedXor* nodep, AstNUser*) {
+    virtual void visit(AstRedXor* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	nodep->iterateChildren(*this);
 	if (nodep->lhsp()->isWide()) {
@@ -862,13 +862,13 @@ private:
 	// which the inlined function does nicely.
     }
 
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	m_stmtp = nodep;
 	nodep->iterateChildren(*this);
 	m_stmtp = NULL;
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	m_stmtp = nodep;
 	nodep->iterateChildren(*this);
@@ -914,8 +914,8 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar*, AstNUser*) {}	// Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}	// Don't hit varrefs under vars
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Gate.cpp b/src/V3Gate.cpp
index d8579b478..6693f62a0 100644
--- a/src/V3Gate.cpp
+++ b/src/V3Gate.cpp
@@ -189,7 +189,7 @@ private:
 	}
     }
     // VISITORS
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	nodep->iterateChildren(*this);
 	// We only allow a LHS ref for the var being set, and a RHS ref for something else being read.
 	if (nodep->varScopep()->varp()->isSc()) {
@@ -215,7 +215,7 @@ private:
 	    m_rhsVarRefs.push_back(nodep);
 	}
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	m_substTreep = nodep->rhsp();
 	if (!nodep->lhsp()->castNodeVarRef())
 	    clearSimple("ASSIGN(non-VARREF)");
@@ -236,7 +236,7 @@ private:
     }
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// *** Special iterator
 	if (!m_isSimple) return;	// Fastpath
 	if (!(m_dedupe ? nodep->isGateDedupable() : nodep->isGateOptimizable())
@@ -360,7 +360,7 @@ private:
     void mergeAssigns();
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	nodep->iterateChildren(*this);
 	//if (debug()>6) m_graph.dump();
 	if (debug()>6) m_graph.dumpDotFilePrefixed("gate_pre");
@@ -383,20 +383,20 @@ private:
 	consumedMove();
 	replaceAssigns();
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_activeReducible = true;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(4," SCOPE "<<nodep<<endl);
 	m_scopep = nodep;
 	m_logicVertexp = NULL;
 	nodep->iterateChildren(*this);
 	m_scopep = NULL;
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Create required blocks and add to module
 	UINFO(4,"  BLOCK  "<<nodep<<endl);
 	m_activeReducible = !(nodep->hasClocked());  // Seq logic outputs aren't reducible
@@ -407,7 +407,7 @@ private:
 	m_activep = NULL;
 	m_activeReducible = true;
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	if (m_scopep) {
 	    if (!m_logicVertexp) nodep->v3fatalSrc("Var ref not under a logic block\n");
 	    AstVarScope* varscp = nodep->varScopep();
@@ -433,19 +433,19 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	iterateNewStmt(nodep, (nodep->isJustOneBodyStmt()?NULL:"Multiple Stmts"), NULL);
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	bool lastslow = m_inSlow;
 	m_inSlow = true;
 	iterateNewStmt(nodep, "AlwaysPublic", NULL);
 	m_inSlow = lastslow;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	iterateNewStmt(nodep, "User C Function", "User C Function");
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	// Note we look at only AstSenItems, not AstSenGate's
 	// The gating term of a AstSenGate is normal logic
 	m_inSenItem = true;
@@ -456,33 +456,33 @@ private:
 	}
 	m_inSenItem = false;
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	// First handle the clock part will be handled in a minute by visit AstSenItem
 	// The logic gating term is delt with as logic
 	iterateNewStmt(nodep, "Clock gater", "Clock gater");
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	bool lastslow = m_inSlow;
 	m_inSlow = true;
 	iterateNewStmt(nodep, (nodep->isJustOneBodyStmt()?NULL:"Multiple Stmts"), NULL);
 	m_inSlow = lastslow;
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	iterateNewStmt(nodep, NULL, NULL);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	iterateNewStmt(nodep, NULL, NULL);
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	iterateNewStmt(nodep, "CoverToggle", "CoverToggle");
     }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) {
+    virtual void visit(AstTraceInc* nodep) {
 	bool lastslow = m_inSlow;
 	m_inSlow = true;
 	iterateNewStmt(nodep, "Tracing", "Tracing");
 	m_inSlow = lastslow;
     }
-    virtual void visit(AstConcat* nodep, AstNUser*) {
+    virtual void visit(AstConcat* nodep) {
 	if (nodep->backp()->castNodeAssign() && nodep->backp()->castNodeAssign()->lhsp()==nodep) {
 	    nodep->v3fatalSrc("Concat on LHS of assignment; V3Const should have deleted it\n");
 	}
@@ -491,7 +491,7 @@ private:
 
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	if (nodep->isOutputter() && m_logicVertexp) m_logicVertexp->setConsumed("outputter");
     }
@@ -796,7 +796,7 @@ private:
     AstNode*	 m_replaceTreep;	// What to replace the variable with
     bool	 m_didReplace;		// Did we do any replacements
     // VISITORS
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	if (nodep->varScopep() == m_elimVarScp) {
 	    // Substitute in the new tree
 	    // It's possible we substitute into something that will be reduced more later
@@ -822,7 +822,7 @@ private:
 	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -929,7 +929,7 @@ private:
     bool		m_dedupable;		// Determined the assign to be dedupable
 
     // VISITORS
-    virtual void visit(AstNodeAssign* assignp, AstNUser*) {
+    virtual void visit(AstNodeAssign* assignp) {
 	if (m_dedupable) {
 	    // I think we could safely dedupe an always block with multiple non-blocking statements, but erring on side of caution here
 	    if (!m_assignp) {
@@ -939,7 +939,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstAlways* alwaysp, AstNUser*) {
+    virtual void visit(AstAlways* alwaysp) {
 	if (m_dedupable) {
 	    if (!m_always) {
 		m_always = true;
@@ -953,7 +953,7 @@ private:
     //  always @(...)
     //    if (...)
     //       foo = ...; // or foo <= ...;
-    virtual void visit(AstNodeIf* ifp, AstNUser*) {
+    virtual void visit(AstNodeIf* ifp) {
 	if (m_dedupable) {
 	    if (m_always && !m_ifCondp && !ifp->elsesp()) {  //we're under an always, this is the first IF,  and there's no else
 		m_ifCondp = ifp->condp();
@@ -964,10 +964,10 @@ private:
 	}
     }
 
-    virtual void visit(AstComment*, AstNUser*) {}  // NOP
+    virtual void visit(AstComment*) {}  // NOP
     //--------------------
     // Default
-    virtual void visit(AstNode*, AstNUser*) {
+    virtual void visit(AstNode*) {
 	m_dedupable = false;
     }
 
@@ -1245,7 +1245,7 @@ void GateVisitor::mergeAssigns() {
 class GateDeassignVisitor : public GateBaseVisitor {
 private:
     // VISITORS
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	if (AstNodeAssign* assp = nodep->valuep()->castNodeAssign()) {
 	    UINFO(5," Removeassign "<<assp<<endl);
 	    AstNode* valuep = assp->rhsp();
@@ -1255,9 +1255,9 @@ private:
 	}
     }
     // Speedups
-    virtual void visit(AstVar* nodep, AstNUser*) {}
-    virtual void visit(AstActive* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {}
+    virtual void visit(AstActive* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3GenClk.cpp b/src/V3GenClk.cpp
index b2355ec1c..3ce9dd530 100644
--- a/src/V3GenClk.cpp
+++ b/src/V3GenClk.cpp
@@ -87,7 +87,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	AstNode::user2ClearTree();	// user2p() used on entire tree
 
 	AstScope* scopep = nodep->scopep();
@@ -97,7 +97,7 @@ private:
 	nodep->iterateChildren(*this);
     }
     //----
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// Consumption/generation of a variable,
 	AstVarScope* vscp = nodep->varScopep();
 	if (!vscp) nodep->v3fatalSrc("Scope not assigned");
@@ -113,18 +113,18 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	m_activep = nodep;
 	nodep->sensesp()->iterateChildren(*this);  // iterateAndNext?
 	m_activep = NULL;
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	nodep->iterateChildren(*this);
     }
 
     //-----
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -154,7 +154,7 @@ private:
     AstNodeModule*	m_topModp;	// Top module
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	AstNode::user1ClearTree();	// user1p() used on entire tree
 	nodep->iterateChildren(*this);
 	{
@@ -163,21 +163,21 @@ private:
 	    GenClkRenameVisitor visitor (nodep, m_topModp);
 	}
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Only track the top scopes, not lower level functions
 	if (nodep->isTop()) {
 	    m_topModp = nodep;
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	nodep->iterateChildren(*this);
 	// Enter the function and trace it
 	nodep->funcp()->accept(*this);
     }
     //----
 
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// Consumption/generation of a variable,
 	AstVarScope* vscp = nodep->varScopep();
 	if (!vscp) nodep->v3fatalSrc("Scope not assigned");
@@ -192,13 +192,13 @@ private:
 	    vscp->circular(true);
 	}
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	//UINFO(8,"ASS "<<nodep<<endl);
 	m_assignp = nodep;
 	nodep->iterateChildren(*this);
 	m_assignp = NULL;
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	UINFO(8,"ACTIVE "<<nodep<<endl);
 	m_activep = nodep;
 	nodep->sensesp()->iterateChildren(*this);  // iterateAndNext?
@@ -207,8 +207,8 @@ private:
     }
 
     //-----
-    virtual void visit(AstVar*, AstNUser*) {}	// Don't want varrefs under it
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}	// Don't want varrefs under it
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Hashed.cpp b/src/V3Hashed.cpp
index 6becdba5c..ace06c554 100644
--- a/src/V3Hashed.cpp
+++ b/src/V3Hashed.cpp
@@ -88,10 +88,10 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar*, AstNUser*) {}
-    virtual void visit(AstTypedef*, AstNUser*) {}
-    virtual void visit(AstParamTypeDType*, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}
+    virtual void visit(AstTypedef*) {}
+    virtual void visit(AstParamTypeDType*) {}
+    virtual void visit(AstNode* nodep) {
 	nodeHashIterate(nodep);
     }
 
diff --git a/src/V3Inline.cpp b/src/V3Inline.cpp
index 2481b6a92..69251a0c2 100644
--- a/src/V3Inline.cpp
+++ b/src/V3Inline.cpp
@@ -91,7 +91,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_stmtCnt = 0;
 	m_modp = nodep;
 	m_modp->user2(CIL_MAYBE);
@@ -123,11 +123,11 @@ private:
 	nodep->user1(doit);
 	m_modp = NULL;
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	nodep->modp()->user3Inc();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstPragma* nodep, AstNUser*) {
+    virtual void visit(AstPragma* nodep) {
 	if (nodep->pragType() == AstPragmaType::INLINE_MODULE) {
 	    //UINFO(0,"PRAG MARK "<<m_modp<<endl);
 	    if (!m_modp) {
@@ -147,21 +147,21 @@ private:
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	// Cleanup link until V3LinkDot can correct it
 	nodep->varp(NULL);
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	// Cleanup link until V3LinkDot can correct it
 	if (!nodep->packagep()) nodep->taskp(NULL);
 	nodep->iterateChildren(*this);
     }
     // Nop's to speed up the loop
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	nodep->iterateChildren(*this);
 	m_stmtCnt++;
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	// Don't count assignments, as they'll likely flatten out
 	// Still need to iterate though to nullify VarXRefs
 	int oldcnt = m_stmtCnt;
@@ -170,7 +170,7 @@ private:
     }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	m_stmtCnt++;
     }
@@ -207,13 +207,13 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	nodep->user4p(nodep->clonep());
     }
     // Accelerate
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {}
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {}
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -248,7 +248,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCellInline* nodep, AstNUser*) {
+    virtual void visit(AstCellInline* nodep) {
 	// Inlined cell under the inline cell, need to move to avoid conflicts
 	nodep->unlinkFrBack();
 	m_modp->addInlinesp(nodep);
@@ -259,17 +259,17 @@ private:
 	// Do CellInlines under this, but don't move them
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	// Cell under the inline cell, need to rename to avoid conflicts
 	string name = m_cellp->name() + "__DOT__" + nodep->name();
 	nodep->name(name);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstModule* nodep) {
 	m_renamedInterfaces.clear();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	if (nodep->user2p()) {
 	    // Make an assignment, so we'll trace it properly
 	    // user2p is either a const or a var.
@@ -337,17 +337,17 @@ private:
 	if (debug()>=9 && nodep->valuep()) { nodep->valuep()->dumpTree(cout,"varchangei:"); }
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	// Function under the inline cell, need to rename to avoid conflicts
 	nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstTypedef* nodep) {
 	// Typedef under the inline cell, need to rename to avoid conflicts
 	nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()->user2p()  // It's being converted to an alias.
 	    && !nodep->varp()->user3()
 	    && !nodep->backp()->castAssignAlias()) { 	// Don't constant propagate aliases (we just made)
@@ -368,7 +368,7 @@ private:
 	nodep->name(nodep->varp()->name());
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	// Track what scope it was originally under so V3LinkDot can resolve it
 	string newname = m_cellp->name();
 	if (nodep->inlinedDots() != "") { newname += "." + nodep->inlinedDots(); }
@@ -378,7 +378,7 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	// Track what scope it was originally under so V3LinkDot can resolve it
 	string newname = m_cellp->name();
 	if (nodep->inlinedDots() != "") { newname += "." + nodep->inlinedDots(); }
@@ -391,9 +391,9 @@ private:
     }
 
     // Not needed, as V3LinkDot doesn't care about typedefs
-    //virtual void visit(AstRefDType* nodep, AstNUser*) {}
+    //virtual void visit(AstRefDType* nodep) {}
 
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
 	// If there's a %m in the display text, we add a special node that will contain the name()
 	// Similar code in V3Begin
 	// To keep correct visual order, must add before other Text's
@@ -407,14 +407,14 @@ private:
 	if (afterp) nodep->scopeEntrp(afterp);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+    virtual void visit(AstCoverDecl* nodep) {
 	// Fix path in coverage statements
 	nodep->hier(m_cellp->prettyName()
 		    + (nodep->hier()!="" ? ".":"")
 		    + nodep->hier());
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -457,11 +457,11 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Iterate modules backwards, in bottom-up order.  Required!
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstIfaceRefDType* nodep, AstNUser*) {
+    virtual void visit(AstIfaceRefDType* nodep) {
 	if (nodep->user5()) {
 	    // The cell has been removed so let's make sure we don't leave a reference to it
 	    // This dtype may still be in use by the AstAssignVarScope created earlier
@@ -469,11 +469,11 @@ private:
 	    nodep->cellp(NULL);
 	}
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	if (nodep->modp()->user1()) {  // Marked with inline request
 	    UINFO(5," Inline CELL   "<<nodep<<endl);
 	    UINFO(5,"   To MOD      "<<m_modp<<endl);
@@ -552,9 +552,9 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {}  // Accelerate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {}  // Accelerate
+    virtual void visit(AstNodeStmt* nodep) {}  // Accelerate
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Inst.cpp b/src/V3Inst.cpp
index e3ac6cade..7d09b862b 100644
--- a/src/V3Inst.cpp
+++ b/src/V3Inst.cpp
@@ -60,14 +60,14 @@ private:
     //int m_debug;  int debug() { return m_debug; }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	//if (nodep->name() == "t_chg") m_debug = 9; else m_debug=0;
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	UINFO(4,"  CELL   "<<nodep<<endl);
 	m_cellp = nodep;
 	//VV*****  We reset user1p() on each cell!!!
@@ -75,7 +75,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_cellp = NULL;
     }
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	// PIN(p,expr) -> ASSIGNW(VARXREF(p),expr)    (if sub's input)
 	//	      or  ASSIGNW(expr,VARXREF(p))    (if sub's output)
 	UINFO(4,"   PIN  "<<nodep<<endl);
@@ -125,7 +125,7 @@ private:
 	nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
     }
 
-    virtual void visit(AstUdpTable* nodep, AstNUser*) {
+    virtual void visit(AstUdpTable* nodep) {
 	if (!v3Global.opt.bboxUnsup()) {
 	    // If we support primitives, update V3Undriven to remove special case
 	    nodep->v3error("Unsupported: Verilog 1995 UDP Tables.  Use --bbox-unsup to ignore tables.");
@@ -133,12 +133,12 @@ private:
     }
 
     // Save some time
-    virtual void visit(AstNodeAssign*, AstNUser*) {}
-    virtual void visit(AstAlways*, AstNUser*) {}
+    virtual void visit(AstNodeAssign*) {}
+    virtual void visit(AstAlways*) {}
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -169,7 +169,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	if (nodep->rangep()) {
 	    m_cellRangep = nodep->rangep();
 	    UINFO(4,"  CELL   "<<nodep<<endl);
@@ -225,7 +225,7 @@ private:
 	}
     }
 
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	bool isIface = nodep->dtypep()->castUnpackArrayDType()
 	    && nodep->dtypep()->castUnpackArrayDType()->subDTypep()->castIfaceRefDType();
 	if (isIface) {
@@ -251,7 +251,7 @@ private:
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	// Any non-direct pins need reconnection with a part-select
 	if (!nodep->exprp()) return; // No-connect
 	if (m_cellRangep) {
@@ -357,10 +357,10 @@ private:
     }
 
     // Save some time
-    virtual void visit(AstNodeMath*, AstNUser*) {}
+    virtual void visit(AstNodeMath*) {}
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Life.cpp b/src/V3Life.cpp
index b4772ddbe..a57ee7500 100644
--- a/src/V3Life.cpp
+++ b/src/V3Life.cpp
@@ -303,7 +303,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// Consumption/generation of a variable,
 	// it's used so can't elim assignment before this use.
 	if (!nodep->varScopep()) nodep->v3fatalSrc("NULL");
@@ -316,7 +316,7 @@ private:
 	    m_lifep->varUsageReplace(vscp, nodep); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	// Collect any used variables first, as lhs may also be on rhs
 	// Similar code in V3Dead
 	vluint64_t lastEdit = AstNode::editCountGbl();	// When it was last edited
@@ -336,13 +336,13 @@ private:
 	    nodep->lhsp()->iterateAndNext(*this);
 	}
     }
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	// Don't treat as normal assign; V3Life doesn't understand time sense
 	nodep->iterateChildren(*this);
     }
 
     //---- Track control flow changes
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	UINFO(4,"   IF "<<nodep<<endl);
 	// Condition is part of PREVIOUS block
 	nodep->condp()->iterateAndNext(*this);
@@ -369,7 +369,7 @@ private:
 	delete elseLifep;
     }
 
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	// While's are a problem, as we don't allow loops in the graph.  We
 	// may go around the cond/body multiple times.  Thus a
 	// lifelication just in the body is ok, but we can't delete an
@@ -399,7 +399,7 @@ private:
 	delete condLifep;
 	delete bodyLifep;
     }
-    virtual void visit(AstJumpLabel* nodep, AstNUser*) {
+    virtual void visit(AstJumpLabel* nodep) {
 	// As with While's we can't predict if a JumpGo will kill us or not
 	// It's worse though as an IF(..., JUMPGO) may change the control flow.
 	// Just don't optimize blocks with labels; they're rare - so far.
@@ -418,7 +418,7 @@ private:
 	bodyLifep->lifeToAbove();
 	delete bodyLifep;
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	//UINFO(4,"  CCALL "<<nodep<<endl);
 	nodep->iterateChildren(*this);
 	// Enter the function and trace it
@@ -426,24 +426,24 @@ private:
 	    nodep->funcp()->accept(*this);
 	}
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	//UINFO(4,"  CCALL "<<nodep<<endl);
 	if (nodep->dpiImport() && !nodep->pure()) {
 	    m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCMath* nodep, AstNUser*) {
+    virtual void visit(AstCMath* nodep) {
 	m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstVar*, AstNUser*) {}	// Don't want varrefs under it
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}	// Don't want varrefs under it
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -475,28 +475,28 @@ private:
     LifeState* m_statep;	// Current state
 
     // VISITORS
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	if (nodep->entryPoint()) {
 	    // Usage model 1: Simulate all C code, doing lifetime analysis
 	    LifeVisitor visitor (nodep, m_statep);
 	}
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	// Usage model 2: Cleanup basic blocks
 	LifeVisitor visitor (nodep, m_statep);
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	// Usage model 2: Cleanup basic blocks
 	LifeVisitor visitor (nodep, m_statep);
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	// Usage model 2: Cleanup basic blocks
 	LifeVisitor visitor (nodep, m_statep);
     }
-    virtual void visit(AstVar*, AstNUser*) {}		// Accelerate
-    virtual void visit(AstNodeStmt*, AstNUser*) {}	// Accelerate
-    virtual void visit(AstNodeMath*, AstNUser*) {}	// Accelerate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}		// Accelerate
+    virtual void visit(AstNodeStmt*) {}	// Accelerate
+    virtual void visit(AstNodeMath*) {}	// Accelerate
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3LifePost.cpp b/src/V3LifePost.cpp
index 060ea2906..e1c9b5b1e 100644
--- a/src/V3LifePost.cpp
+++ b/src/V3LifePost.cpp
@@ -61,7 +61,7 @@ private:
     //  AstVarScope::user4p()	-> AstVarScope*, If set, replace this varscope with specified new one
     // STATE
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	AstVarScope* vscp = nodep->varScopep();
 	if (!vscp) nodep->v3fatalSrc("Scope not assigned");
 	if (AstVarScope* newvscp = (AstVarScope*)vscp->user4p()) {
@@ -71,17 +71,17 @@ private:
 	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Only track the top scopes, not lower level functions
 	if (nodep->isTop()) nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	nodep->iterateChildren(*this);
 	// Enter the function and trace it
 	nodep->funcp()->accept(*this);
     }
-    virtual void visit(AstVar*, AstNUser*) {}	// Don't want varrefs under it
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}	// Don't want varrefs under it
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -111,7 +111,7 @@ private:
     V3Double0		m_statAssnDel;	// Statistic tracking
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	AstNode::user1ClearTree();	// user1p() used on entire tree
 	AstNode::user2ClearTree();	// user2p() used on entire tree
 	AstNode::user4ClearTree();	// user4p() used on entire tree
@@ -122,7 +122,7 @@ private:
 	LifePostElimVisitor visitor (nodep);
     }
 
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// Consumption/generation of a variable,
 	AstVarScope* vscp = nodep->varScopep();
 	if (!vscp) nodep->v3fatalSrc("Scope not assigned");
@@ -135,7 +135,7 @@ private:
 	    vscp->user2(m_sequence);
 	}
     }
-    virtual void visit(AstAssignPost* nodep, AstNUser*) {
+    virtual void visit(AstAssignPost* nodep) {
 	if (AstVarRef* lhsp = nodep->lhsp()->castVarRef()) {
 	    if (AstVarRef* rhsp = nodep->rhsp()->castVarRef()) {
 		// Scrunch these:
@@ -161,19 +161,19 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Only track the top scopes, not lower level functions
 	if (nodep->isTop()) nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	nodep->iterateChildren(*this);
 	// Enter the function and trace it
 	nodep->funcp()->accept(*this);
     }
 
     //-----
-    virtual void visit(AstVar*, AstNUser*) {}	// Don't want varrefs under it
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}	// Don't want varrefs under it
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp
index fbed9a1de..7bea24ce7 100644
--- a/src/V3LinkCells.cpp
+++ b/src/V3LinkCells.cpp
@@ -151,7 +151,7 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	AstNode::user1ClearTree();
 	readModNames();
 	nodep->iterateChildren(*this);
@@ -182,7 +182,7 @@ private:
 	    v3error("Specified --top-module '"<<v3Global.opt.topModule()<<"' was not found in design.");
 	}
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Module: Pick up modnames, so we can resolve cells later
 	m_modp = nodep;
 	UINFO(2,"Link Module: "<<nodep<<endl);
@@ -217,7 +217,7 @@ private:
 	m_modp = NULL;
     }
 
-    virtual void visit(AstIfaceRefDType* nodep, AstNUser*) {
+    virtual void visit(AstIfaceRefDType* nodep) {
 	// Cell: Resolve its filename.  If necessary, parse it.
 	UINFO(4,"Link IfaceRef: "<<nodep<<endl);
 	// Use findIdUpward instead of findIdFlat; it doesn't matter for now
@@ -236,14 +236,14 @@ private:
 	// Note cannot do modport resolution here; modports are allowed underneath generates
     }
 
-    virtual void visit(AstPackageImport* nodep, AstNUser*) {
+    virtual void visit(AstPackageImport* nodep) {
 	// Package Import: We need to do the package before the use of a package
 	nodep->iterateChildren(*this);
 	if (!nodep->packagep()) nodep->v3fatalSrc("Unlinked package");  // Parser should set packagep
 	new V3GraphEdge(&m_graph, vertex(m_modp), vertex(nodep->packagep()), 1, false);
     }
 
-    virtual void visit(AstBind* nodep, AstNUser*) {
+    virtual void visit(AstBind* nodep) {
 	// Bind: Has cells underneath that need to be put into the new module, and cells which need resolution
 	// TODO this doesn't allow bind to dotted hier names, that would require
 	// this move to post param, which would mean we do not auto-read modules
@@ -264,7 +264,7 @@ private:
 	pushDeletep(nodep->unlinkFrBack());
     }
 
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	// Cell: Resolve its filename.  If necessary, parse it.
 	if (nodep->user1SetOnce()) return;  // AstBind and AstNodeModule may call a cell twice
 	if (!nodep->modp()) {
@@ -382,8 +382,8 @@ private:
 
     // Accelerate the recursion
     // Must do statements to support Generates, math though...
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp
index bc42487b0..31d630fc2 100644
--- a/src/V3LinkDot.cpp
+++ b/src/V3LinkDot.cpp
@@ -635,7 +635,7 @@ class LinkDotFindVisitor : public AstNVisitor {
     }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Process $unit or other packages
 	// Not needed - dotted references not allowed from inside packages
 	//for (AstNodeModule* nodep = v3Global.rootp()->modulesp(); nodep; nodep=nodep->nextp()->castNodeModule()) {
@@ -663,8 +663,8 @@ class LinkDotFindVisitor : public AstNVisitor {
 	    m_curSymp = m_modSymp = NULL;
 	}
     }
-    virtual void visit(AstTypeTable* nodep, AstNUser*) {}
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstTypeTable* nodep) {}
+    virtual void visit(AstNodeModule* nodep) {
 	// Called on top module from Netlist, other modules from the cell creating them,
 	// and packages
 	UINFO(8,"   "<<nodep<<endl);
@@ -719,11 +719,11 @@ class LinkDotFindVisitor : public AstNVisitor {
 	// Prep for next
 	m_packagep = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	if (!m_statep->forScopeCreation()) v3fatalSrc("Scopes should only exist right after V3Scope");
 	// Ignored.  Processed in next step
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	UINFO(5,"   CELL under "<<m_scope<<" is "<<nodep<<endl);
 	// Process XREFs/etc inside pins
 	nodep->iterateChildren(*this);
@@ -760,7 +760,7 @@ class LinkDotFindVisitor : public AstNVisitor {
 	m_curSymp = oldCurSymp;
 	m_paramNum = oldParamNum;
     }
-    virtual void visit(AstCellInline* nodep, AstNUser*) {
+    virtual void visit(AstCellInline* nodep) {
 	UINFO(5,"   CELLINLINE under "<<m_scope<<" is "<<nodep<<endl);
 	VSymEnt* aboveSymp = m_curSymp;
 	// If baz__DOT__foo__DOT__bar, we need to find baz__DOT__foo and add bar to it.
@@ -780,11 +780,11 @@ class LinkDotFindVisitor : public AstNVisitor {
 	    m_statep->insertInline(aboveSymp, m_modSymp, nodep, nodep->name());
 	}
     }
-    virtual void visit(AstDefParam* nodep, AstNUser*) {
+    virtual void visit(AstDefParam* nodep) {
 	nodep->user1p(m_curSymp);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstGenerate* nodep, AstNUser*) {
+    virtual void visit(AstGenerate* nodep) {
 	// Begin: ... blocks often replicate under genif/genfor, so simply suppress duplicate checks
 	// See t_gen_forif.v for an example.
 	bool lastInGen = m_inGenerate;
@@ -794,7 +794,7 @@ class LinkDotFindVisitor : public AstNVisitor {
 	}
 	m_inGenerate = lastInGen;
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	UINFO(5,"   "<<nodep<<endl);
 	// Rename "genblk"s to include a number
 	if (m_statep->forPrimary() && !nodep->user4SetOnce()) {
@@ -836,7 +836,7 @@ class LinkDotFindVisitor : public AstNVisitor {
 	m_beginp = oldbegin;
 	m_beginNum = oldNum;
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	// NodeTask: Remember its name for later resolution
 	UINFO(5,"   "<<nodep<<endl);
 	if (!m_curSymp || !m_modSymp) nodep->v3fatalSrc("Function/Task not under module??\n");
@@ -871,7 +871,7 @@ class LinkDotFindVisitor : public AstNVisitor {
 	}
 	m_curSymp = oldCurSymp;
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	// Var: Remember its name for later resolution
 	if (!m_curSymp || !m_modSymp) nodep->v3fatalSrc("Var not under module??\n");
 	nodep->iterateChildren(*this);
@@ -955,22 +955,22 @@ class LinkDotFindVisitor : public AstNVisitor {
 	    }
 	}
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstTypedef* nodep) {
 	// Remember its name for later resolution
 	if (!m_curSymp) nodep->v3fatalSrc("Typedef not under module??\n");
 	nodep->iterateChildren(*this);
 	m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_packagep);
     }
-    virtual void visit(AstParamTypeDType* nodep, AstNUser*) {
+    virtual void visit(AstParamTypeDType* nodep) {
 	if (!m_curSymp) nodep->v3fatalSrc("Parameter type not under module??\n");
 	nodep->iterateChildren(*this);
 	m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_packagep);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	// For dotted resolution, ignore all AstVars under functions, otherwise shouldn't exist
 	if (m_statep->forScopeCreation()) nodep->v3fatalSrc("No CFuncs expected in tree yet");
     }
-    virtual void visit(AstEnumItem* nodep, AstNUser*) {
+    virtual void visit(AstEnumItem* nodep) {
 	// EnumItem: Remember its name for later resolution
 	nodep->iterateChildren(*this);
 	// Find under either a task or the module's vars
@@ -1000,7 +1000,7 @@ class LinkDotFindVisitor : public AstNVisitor {
 	    m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_packagep);
 	}
     }
-    virtual void visit(AstPackageImport* nodep, AstNUser*) {
+    virtual void visit(AstPackageImport* nodep) {
 	UINFO(2,"  Link: "<<nodep<<endl);
 	VSymEnt* srcp = m_statep->getNodeSym(nodep->packagep());
 	if (nodep->name()!="*") {
@@ -1014,7 +1014,7 @@ class LinkDotFindVisitor : public AstNVisitor {
 	// No longer needed, but can't delete until any multi-instantiated modules are expanded
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -1078,8 +1078,8 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstTypeTable* nodep, AstNUser*) {}
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstTypeTable* nodep) {}
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(5,"   "<<nodep<<endl);
 	if (nodep->dead() || !nodep->user4()) {
 	    UINFO(4,"Mark dead module "<<nodep<<endl);
@@ -1094,7 +1094,7 @@ private:
 	    m_modp = NULL;
 	}
     }
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	// Pin: Link to submodule's port
 	// Deal with implicit definitions - do before Resolve visitor as may be referenced above declaration
 	if (nodep->exprp() // Else specifically unconnected pin
@@ -1102,7 +1102,7 @@ private:
 	    pinImplicitExprRecurse(nodep->exprp());
 	}
     }
-    virtual void visit(AstDefParam* nodep, AstNUser*) {
+    virtual void visit(AstDefParam* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->v3warn(DEFPARAM,"Suggest replace defparam with Verilog 2001 #(."<<nodep->prettyName()<<"(...etc...))");
 	VSymEnt* foundp = m_statep->getNodeSym(nodep)->findIdFallback(nodep->path());
@@ -1123,7 +1123,7 @@ private:
 	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstPort* nodep, AstNUser*) {
+    virtual void visit(AstPort* nodep) {
 	// Port: Stash the pin number
 	// Need to set pin numbers after varnames are created
 	// But before we do the final resolution based on names
@@ -1142,14 +1142,14 @@ private:
 	// Ports not needed any more
 	nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	// Deal with implicit definitions
 	// We used to nodep->allowImplicit() here, but it turns out
 	// normal "assigns" can also make implicit wires.  Yuk.
 	pinImplicitExprRecurse(nodep->lhsp());
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	// tran gates need implicit creation
 	// As VarRefs don't exist in forPrimary, sanity check
 	if (m_statep->forPrimary()) nodep->v3fatalSrc("Assign aliases unexpected pre-dot");
@@ -1161,13 +1161,13 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstImplicit* nodep, AstNUser*) {
+    virtual void visit(AstImplicit* nodep) {
 	// Unsupported gates need implicit creation
 	pinImplicitExprRecurse(nodep);
 	// We're done with implicit gates
 	nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -1197,11 +1197,11 @@ class LinkDotScopeVisitor : public AstNVisitor {
     int debug() { return LinkDotState::debug(); }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep, AstNUser* vup) {
+    virtual void visit(AstNetlist* nodep) {
 	// Recurse..., backward as must do packages before using packages
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(8,"  SCOPE "<<nodep<<endl);
 	if (!m_statep->forScopeCreation()) v3fatalSrc("Scopes should only exist right after V3Scope");
 	// Using the CELL names, we created all hierarchy.  We now need to match this Scope
@@ -1212,7 +1212,7 @@ class LinkDotScopeVisitor : public AstNVisitor {
 	m_modSymp = NULL;
 	m_scopep = NULL;
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	if (!nodep->varp()->isFuncLocal()) {
 	    VSymEnt* varSymp = m_statep->insertSym(m_modSymp, nodep->varp()->name(), nodep, NULL);
 	    if (nodep->varp()->isIfaceRef()
@@ -1239,12 +1239,12 @@ class LinkDotScopeVisitor : public AstNVisitor {
 	    }
 	}
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	VSymEnt* symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, NULL);
 	symp->fallbackp(m_modSymp);
 	// No recursion, we don't want to pick up variables
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	// Track aliases created by V3Inline; if we get a VARXREF(aliased_from)
 	// we'll need to replace it with a VARXREF(aliased_to)
 	if (debug()>=9) nodep->dumpTree(cout,"-\t\t\t\talias: ");
@@ -1254,7 +1254,7 @@ class LinkDotScopeVisitor : public AstNVisitor {
 	fromVscp->user2p(toVscp);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstAssignVarScope* nodep, AstNUser*) {
+    virtual void visit(AstAssignVarScope* nodep) {
 	UINFO(5,"ASSIGNVARSCOPE  "<<nodep<<endl);
 	if (debug()>=9) nodep->dumpTree(cout,"-\t\t\t\tavs: ");
 	VSymEnt* rhsSymp;
@@ -1299,10 +1299,10 @@ class LinkDotScopeVisitor : public AstNVisitor {
     }
     // For speed, don't recurse things that can't have scope
     // Note we allow AstNodeStmt's as generates may be under them
-    virtual void visit(AstCell*, AstNUser*) {}
-    virtual void visit(AstVar*, AstNUser*) {}
-    virtual void visit(AstNodeMath*, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstCell*) {}
+    virtual void visit(AstVar*) {}
+    virtual void visit(AstNodeMath*) {}
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -1332,7 +1332,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
     int debug() { return LinkDotState::debug(); }
 
     // VISITs
-    virtual void visit(AstModport* nodep, AstNUser*) {
+    virtual void visit(AstModport* nodep) {
 	// Modport: Remember its name for later resolution
 	UINFO(5,"   fiv: "<<nodep<<endl);
 	VSymEnt* oldCurSymp = m_curSymp;
@@ -1344,7 +1344,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
 	}
 	m_curSymp = oldCurSymp;
     }
-    virtual void visit(AstModportFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstModportFTaskRef* nodep) {
 	UINFO(5,"   fif: "<<nodep<<endl);
 	nodep->iterateChildren(*this);
 	if (nodep->isExport()) nodep->v3error("Unsupported: modport export");
@@ -1365,7 +1365,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
 	    nodep->unlinkFrBack(); pushDeletep(nodep); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstModportVarRef* nodep, AstNUser*) {
+    virtual void visit(AstModportVarRef* nodep) {
 	UINFO(5,"   fiv: "<<nodep<<endl);
 	nodep->iterateChildren(*this);
 	VSymEnt* symp = m_curSymp->findIdFallback(nodep->name());
@@ -1388,7 +1388,7 @@ class LinkDotIfaceVisitor : public AstNVisitor {
 	    nodep->unlinkFrBack(); pushDeletep(nodep); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -1524,12 +1524,12 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep, AstNUser* vup) {
+    virtual void visit(AstNetlist* nodep) {
 	// Recurse..., backward as must do packages before using packages
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstTypeTable* nodep, AstNUser*) {}
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstTypeTable* nodep) {}
+    virtual void visit(AstNodeModule* nodep) {
 	if (nodep->dead()) return;
 	checkNoDot(nodep);
 	UINFO(8,"  "<<nodep<<endl);
@@ -1542,7 +1542,7 @@ private:
 	m_modp = NULL;
 	m_ds.m_dotSymp = m_curSymp = m_modSymp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(8,"   "<<nodep<<endl);
 	VSymEnt* oldModSymp = m_modSymp;
 	VSymEnt* oldCurSymp = m_curSymp;
@@ -1553,13 +1553,13 @@ private:
 	m_modSymp = oldModSymp;
 	m_curSymp = oldCurSymp;
     }
-    virtual void visit(AstCellInline* nodep, AstNUser*) {
+    virtual void visit(AstCellInline* nodep) {
 	checkNoDot(nodep);
 	if (m_statep->forScopeCreation()) {
 	    nodep->unlinkFrBack(); pushDeletep(nodep); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	// Cell: Recurse inside or cleanup not founds
 	checkNoDot(nodep);
 	m_cellp = nodep;
@@ -1588,7 +1588,7 @@ private:
 	// Parent module inherits child's publicity
 	// This is done bottom up in the LinkBotupVisitor stage
     }
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	// Pin: Link to submodule's port
 	checkNoDot(nodep);
 	nodep->iterateChildren(*this);
@@ -1622,7 +1622,7 @@ private:
 	}
 	// Early return() above when deleted
     }
-    virtual void visit(AstDot* nodep, AstNUser*) {
+    virtual void visit(AstDot* nodep) {
 	// Legal under a DOT: AstDot, AstParseRef, AstPackageRef, AstNodeSel
 	//    also a DOT can be part of an expression, but only above plus AstFTaskRef are legal children
 	// DOT(PACKAGEREF, PARSEREF(text))
@@ -1683,7 +1683,7 @@ private:
 	    m_ds.m_dotp = lastStates.m_dotp;
 	}
     }
-    virtual void visit(AstParseRef* nodep, AstNUser*) {
+    virtual void visit(AstParseRef* nodep) {
 	if (nodep->user3SetOnce()) return;
 	UINFO(9,"   linkPARSEREF "<<m_ds.ascii()<<"  n="<<nodep<<endl);
 	// m_curSymp is symbol table of outer expression
@@ -1889,7 +1889,7 @@ private:
 	    m_ds = lastStates;
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// VarRef: Resolve its reference
 	// ParseRefs are used the first pass (forPrimary) so we shouldn't get can't find
 	// errors here now that we have a VarRef.
@@ -1908,7 +1908,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	// VarRef: Resolve its reference
 	// We always link even if varp() is set, because the module we choose may change
 	// due to creating new modules, flattening, etc.
@@ -1973,11 +1973,11 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstEnumItemRef* nodep, AstNUser*) {
+    virtual void visit(AstEnumItemRef* nodep) {
 	// EnumItemRef may be under a dot.  Should already be resolved.
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstMethodSel* nodep, AstNUser*) {
+    virtual void visit(AstMethodSel* nodep) {
 	// Created here so should already be resolved.
 	DotStates lastStates = m_ds;
 	{
@@ -1986,14 +1986,14 @@ private:
 	}
 	m_ds = lastStates;
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	checkNoDot(nodep);
 	nodep->iterateChildren(*this);
 	if (m_statep->forPrimary() && nodep->isIO() && !m_ftaskp && !nodep->user4()) {
 	    nodep->v3error("Input/output/inout does not appear in port list: "<<nodep->prettyName());
 	}
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	if (nodep->user3SetOnce()) return;
 	UINFO(8,"     "<<nodep<<endl);
 	if (m_ds.m_dotp && m_ds.m_dotPos == DP_PACKAGE) {
@@ -2084,7 +2084,7 @@ private:
 	}
 	m_ds = lastStates;
     }
-    virtual void visit(AstSelBit* nodep, AstNUser*) {
+    virtual void visit(AstSelBit* nodep) {
 	if (nodep->user3SetOnce()) return;
 	nodep->lhsp()->iterateAndNext(*this);
 	if (m_ds.m_dotPos == DP_SCOPE) { // Already under dot, so this is {modulepart} DOT {modulepart}
@@ -2108,7 +2108,7 @@ private:
 	    nodep->replaceWith(newp); pushDeletep(nodep); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstNodePreSel* nodep, AstNUser*) {
+    virtual void visit(AstNodePreSel* nodep) {
 	// Excludes simple AstSelBit, see above
 	if (nodep->user3SetOnce()) return;
 	if (m_ds.m_dotPos == DP_SCOPE) { // Already under dot, so this is {modulepart} DOT {modulepart}
@@ -2126,11 +2126,11 @@ private:
 	}
 	m_ds = lastStates;
     }
-    virtual void visit(AstMemberSel* nodep, AstNUser*) {
+    virtual void visit(AstMemberSel* nodep) {
 	// checkNoDot not appropriate, can be under a dot
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	UINFO(5,"   "<<nodep<<endl);
 	checkNoDot(nodep);
 	VSymEnt* oldCurSymp = m_curSymp;
@@ -2142,7 +2142,7 @@ private:
 	m_ds.m_dotSymp = m_curSymp = oldCurSymp;
 	UINFO(5,"   cur=se"<<(void*)m_curSymp<<endl);
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	UINFO(5,"   "<<nodep<<endl);
 	checkNoDot(nodep);
 	VSymEnt* oldCurSymp = m_curSymp;
@@ -2154,7 +2154,7 @@ private:
 	m_ds.m_dotSymp = m_curSymp = oldCurSymp;
 	m_ftaskp = NULL;
     }
-    virtual void visit(AstRefDType* nodep, AstNUser*) {
+    virtual void visit(AstRefDType* nodep) {
 	// Resolve its reference
 	if (nodep->user3SetOnce()) return;
 	if (m_ds.m_dotp && m_ds.m_dotPos == DP_PACKAGE) {
@@ -2187,7 +2187,7 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstDpiExport* nodep, AstNUser*) {
+    virtual void visit(AstDpiExport* nodep) {
 	// AstDpiExport: Make sure the function referenced exists, then dump it
 	nodep->iterateChildren(*this);
 	checkNoDot(nodep);
@@ -2202,25 +2202,25 @@ private:
 	}
 	nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstPackageImport* nodep, AstNUser*) {
+    virtual void visit(AstPackageImport* nodep) {
 	// No longer needed
 	checkNoDot(nodep);
 	nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstCellRef* nodep, AstNUser*) {
+    virtual void visit(AstCellRef* nodep) {
 	UINFO(5,"  AstCellRef: "<<nodep<<" "<<m_ds.ascii()<<endl);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCellArrayRef* nodep, AstNUser*) {
+    virtual void visit(AstCellArrayRef* nodep) {
 	UINFO(5,"  AstCellArrayRef: "<<nodep<<" "<<m_ds.ascii()<<endl);
 	// Expression already iterated
     }
-    virtual void visit(AstUnlinkedRef* nodep, AstNUser*) {
+    virtual void visit(AstUnlinkedRef* nodep) {
 	UINFO(5,"  AstCellArrayRef: "<<nodep<<" "<<m_ds.ascii()<<endl);
 	// No need to iterate, if we have a UnlinkedVarXRef, we're already done
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	checkNoDot(nodep);
 	nodep->iterateChildren(*this);
diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp
index f5d5ec990..1f1d830ca 100644
--- a/src/V3LinkJump.cpp
+++ b/src/V3LinkJump.cpp
@@ -113,25 +113,25 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	if (nodep->dead()) return;
 	m_modp = nodep;
 	m_repeatNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	m_ftaskp = nodep;
 	nodep->iterateChildren(*this);
 	m_ftaskp = NULL;
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	UINFO(8,"  "<<nodep<<endl);
 	m_beginStack.push_back(nodep);
 	nodep->iterateChildren(*this);
 	m_beginStack.pop_back();
     }
-    virtual void visit(AstRepeat* nodep, AstNUser*) {
+    virtual void visit(AstRepeat* nodep) {
 	// So later optimizations don't need to deal with them,
 	//    REPEAT(count,body) -> loop=count,WHILE(loop>0) { body, loop-- }
 	// Note var can be signed or unsigned based on original number.
@@ -161,7 +161,7 @@ private:
 	nodep->replaceWith(newp);
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	// Don't need to track AstRepeat/AstFor as they have already been converted
 	AstWhile* lastLoopp = m_loopp;
 	bool lastInc = m_loopInc;
@@ -175,7 +175,7 @@ private:
 	m_loopInc = lastInc;
 	m_loopp = lastLoopp;
     }
-    virtual void visit(AstReturn* nodep, AstNUser*) {
+    virtual void visit(AstReturn* nodep) {
 	nodep->iterateChildren(*this);
 	AstFunc* funcp = m_ftaskp->castFunc();
 	if (!m_ftaskp) { nodep->v3error("Return isn't underneath a task or function"); }
@@ -194,7 +194,7 @@ private:
 	}
 	nodep->unlinkFrBack(); pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstBreak* nodep, AstNUser*) {
+    virtual void visit(AstBreak* nodep) {
 	nodep->iterateChildren(*this);
 	if (!m_loopp) { nodep->v3error("break isn't underneath a loop"); }
 	else {
@@ -204,7 +204,7 @@ private:
 	}
 	nodep->unlinkFrBack(); pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstContinue* nodep, AstNUser*) {
+    virtual void visit(AstContinue* nodep) {
 	nodep->iterateChildren(*this);
 	if (!m_loopp) { nodep->v3error("continue isn't underneath a loop"); }
 	else {
@@ -215,7 +215,7 @@ private:
 	}
 	nodep->unlinkFrBack(); pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstDisable* nodep, AstNUser*) {
+    virtual void visit(AstDisable* nodep) {
 	UINFO(8,"   DISABLE "<<nodep<<endl);
 	nodep->iterateChildren(*this);
 	AstBegin* beginp = NULL;
@@ -236,12 +236,12 @@ private:
 	nodep->unlinkFrBack(); pushDeletep(nodep); VL_DANGLING(nodep);
 	//if (debug()>=9) { UINFO(0,"\n"); beginp->dumpTree(cout,"  labelo: "); }
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (m_loopInc && nodep->varp()) nodep->varp()->usedLoopIdx(true);
     }
 
-    virtual void visit(AstConst* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3LinkLValue.cpp b/src/V3LinkLValue.cpp
index 68d73489f..5d201cb09 100644
--- a/src/V3LinkLValue.cpp
+++ b/src/V3LinkLValue.cpp
@@ -55,7 +55,7 @@ private:
 
     // VISITs
     // Result handing
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	// VarRef: LValue its reference
 	if (m_setRefLvalue) {
 	    nodep->lvalue(true);
@@ -71,7 +71,7 @@ private:
     }
 
     // Nodes that start propagating down lvalues
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	if (nodep->modVarp() && nodep->modVarp()->isOutput()) {
 	    // When the varref's were created, we didn't know the I/O state
 	    // Now that we do, and it's from a output, we know it's a lvalue
@@ -82,7 +82,7 @@ private:
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -92,7 +92,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstFOpen* nodep, AstNUser*) {
+    virtual void visit(AstFOpen* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -103,7 +103,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstFClose* nodep, AstNUser*) {
+    virtual void visit(AstFClose* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -111,7 +111,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstFFlush* nodep, AstNUser*) {
+    virtual void visit(AstFFlush* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -119,7 +119,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstFGetC* nodep, AstNUser*) {
+    virtual void visit(AstFGetC* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -127,7 +127,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstFGetS* nodep, AstNUser*) {
+    virtual void visit(AstFGetS* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -136,7 +136,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstFScanF* nodep, AstNUser*) {
+    virtual void visit(AstFScanF* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -145,7 +145,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstSScanF* nodep, AstNUser*) {
+    virtual void visit(AstSScanF* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -153,13 +153,13 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstSysIgnore* nodep, AstNUser*) {
+    virtual void visit(AstSysIgnore* nodep) {
 	// Can't know if lvalue or not; presume so as stricter
 	bool last_setRefLvalue = m_setRefLvalue;
 	nodep->iterateChildren(*this);
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstReadMem* nodep, AstNUser*) {
+    virtual void visit(AstReadMem* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -171,7 +171,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstValuePlusArgs* nodep, AstNUser*) {
+    virtual void visit(AstValuePlusArgs* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -179,7 +179,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstSFormat* nodep, AstNUser*) {
+    virtual void visit(AstSFormat* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    m_setRefLvalue = true;
@@ -191,7 +191,7 @@ private:
     }
 
     // Nodes that change LValue state
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{
 	    nodep->lhsp()->iterateAndNext(*this);
@@ -202,7 +202,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstNodeSel* nodep, AstNUser*) {
+    virtual void visit(AstNodeSel* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{   // Only set lvalues on the from
 	    nodep->lhsp()->iterateAndNext(*this);
@@ -211,7 +211,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstCellArrayRef* nodep, AstNUser*) {
+    virtual void visit(AstCellArrayRef* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{   // selp is not an lvalue
 	    m_setRefLvalue = false;
@@ -219,7 +219,7 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstNodePreSel* nodep, AstNUser*) {
+    virtual void visit(AstNodePreSel* nodep) {
 	bool last_setRefLvalue = m_setRefLvalue;
 	{   // Only set lvalues on the from
 	    nodep->lhsp()->iterateAndNext(*this);
@@ -229,12 +229,12 @@ private:
 	}
 	m_setRefLvalue = last_setRefLvalue;
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	m_ftaskp = nodep;
 	nodep->iterateChildren(*this);
 	m_ftaskp = NULL;
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	AstNode* pinp = nodep->pinsp();
 	AstNodeFTask* taskp = nodep->taskp();
 	// We'll deal with mismatching pins later
@@ -256,7 +256,7 @@ private:
 	}
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp
index 6c34e5656..ccc545caf 100644
--- a/src/V3LinkParse.cpp
+++ b/src/V3LinkParse.cpp
@@ -87,7 +87,7 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	if (!nodep->user1SetOnce()) {  // Process only once.
 	    cleanFileline(nodep);
 	    m_ftaskp = nodep;
@@ -95,7 +95,7 @@ private:
 	    m_ftaskp = NULL;
 	}
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	if (!nodep->user1SetOnce()) {  // Process only once.
 	    cleanFileline(nodep);
 	    UINFO(5,"   "<<nodep<<endl);
@@ -105,7 +105,7 @@ private:
 	    m_valueModp = upperValueModp;
 	}
     }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeDType* nodep) {
 	if (!nodep->user1SetOnce()) {  // Process only once.
 	    cleanFileline(nodep);
 	    AstNodeDType* upperDtypep = m_dtypep;
@@ -114,7 +114,7 @@ private:
 	    m_dtypep = upperDtypep;
 	}
     }
-    virtual void visit(AstEnumItem* nodep, AstNUser*) {
+    virtual void visit(AstEnumItem* nodep) {
 	// Expand ranges
 	cleanFileline(nodep);
 	nodep->iterateChildren(*this);
@@ -138,7 +138,7 @@ private:
 	}
     }
 
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	cleanFileline(nodep);
 	if (nodep->subDTypep()->castParseTypeDType()) {
 	    // It's a parameter type. Use a different node type for this.
@@ -198,7 +198,7 @@ private:
 	}
     }
 
-    virtual void visit(AstAttrOf* nodep, AstNUser*) {
+    virtual void visit(AstAttrOf* nodep) {
 	cleanFileline(nodep);
 	nodep->iterateChildren(*this);
 	if (nodep->attrType() == AstAttrType::DT_PUBLIC) {
@@ -264,7 +264,7 @@ private:
 	}
     }
 
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	// AlwaysPublic was attached under a var, but it's a statement that should be
 	// at the same level as the var
 	cleanFileline(nodep);
@@ -279,7 +279,7 @@ private:
 	}
     }
 
-    virtual void visit(AstDefImplicitDType* nodep, AstNUser*) {
+    virtual void visit(AstDefImplicitDType* nodep) {
 	cleanFileline(nodep);
 	UINFO(8,"   DEFIMPLICIT "<<nodep<<endl);
 	// Must remember what names we've already created, and combine duplicates
@@ -315,14 +315,14 @@ private:
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
-    virtual void visit(AstTypedefFwd* nodep, AstNUser*) {
+    virtual void visit(AstTypedefFwd* nodep) {
 	// We only needed the forward declaration in order to parse correctly.
 	// We won't even check it was ever really defined, as it might have been in a header
 	// file referring to a module we never needed
 	nodep->unlinkFrBack()->deleteTree();
     }
 
-    virtual void visit(AstForeach* nodep, AstNUser*) {
+    virtual void visit(AstForeach* nodep) {
 	// FOREACH(array,loopvars,body)
 	// -> BEGIN(declare vars, loopa=lowest; WHILE(loopa<=highest, ... body))
 	//nodep->dumpTree(cout, "-foreach-old:");
@@ -367,7 +367,7 @@ private:
 	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Module: Create sim table for entire module and iterate
 	cleanFileline(nodep);
 	//
@@ -386,22 +386,22 @@ private:
 	nodep->iterateChildren(*this);
 	m_valueModp = upperValueModp;
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	visitIterateNoValueMod(nodep);
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	visitIterateNoValueMod(nodep);
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	m_inAlways = true;
 	visitIterateNoValueMod(nodep);
 	m_inAlways = false;
     }
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    virtual void visit(AstPslCover* nodep) {
 	visitIterateNoValueMod(nodep);
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	cleanFileline(nodep);
 	nodep->iterateChildren(*this);
diff --git a/src/V3LinkResolve.cpp b/src/V3LinkResolve.cpp
index e6d5dfa58..72874e269 100644
--- a/src/V3LinkResolve.cpp
+++ b/src/V3LinkResolve.cpp
@@ -70,7 +70,7 @@ private:
     // TODO: Most of these visitors are here for historical reasons.
     // TODO: ExpectDecriptor can move to data type resolution, and the rest
     // TODO: could move to V3LinkParse to get them out of the way of elaboration
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Module: Create sim table for entire module and iterate
 	UINFO(8,"MODULE "<<nodep<<endl);
 	if (nodep->dead()) return;
@@ -79,21 +79,21 @@ private:
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	nodep->iterateChildren(*this);
 	// Initial assignments under function/tasks can just be simple assignments without the initial
 	if (m_ftaskp) {
 	    nodep->replaceWith(nodep->bodysp()->unlinkFrBackWithNext()); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstVAssert* nodep, AstNUser*) {
+    virtual void visit(AstVAssert* nodep) {
 	if (m_assertp) nodep->v3error("Assert not allowed under another assert");
 	m_assertp = nodep;
 	nodep->iterateChildren(*this);
 	m_assertp = NULL;
     }
 
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_ftaskp) nodep->funcLocal(true);
 	if (nodep->isSigModPublic()) {
@@ -102,7 +102,7 @@ private:
 	}
     }
 
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	// VarRef: Resolve its reference
 	if (nodep->varp()) {
 	    nodep->varp()->usedParam(true);
@@ -110,7 +110,7 @@ private:
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	// NodeTask: Remember its name for later resolution
 	// Remember the existing symbol table scope
 	m_ftaskp = nodep;
@@ -120,14 +120,14 @@ private:
 	    nodep->scopeNamep(new AstScopeName(nodep->fileline()));
 	}
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (nodep->taskp() && (nodep->taskp()->dpiContext() || nodep->taskp()->dpiExport())) {
 	    nodep->scopeNamep(new AstScopeName(nodep->fileline()));
 	}
     }
 
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	// Remove bit selects, and bark if it's not a simple variable
 	nodep->iterateChildren(*this);
 	if (nodep->isClocked()) {
@@ -190,11 +190,11 @@ private:
 	    nodep->v3error("Unsupported: Complex statement in sensitivity list");
 	}
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	nodep->v3fatalSrc("SenGates shouldn't be in tree yet");
     }
 
-    virtual void visit(AstNodePreSel* nodep, AstNUser*) {
+    virtual void visit(AstNodePreSel* nodep) {
 	if (!nodep->attrp()) {
 	    nodep->iterateChildren(*this);
 	    // Constification may change the fromp() to a constant, which will lose the
@@ -221,7 +221,7 @@ private:
 	}
     }
 
-    virtual void visit(AstCaseItem* nodep, AstNUser*) {
+    virtual void visit(AstCaseItem* nodep) {
 	// Move default caseItems to the bottom of the list
 	// That saves us from having to search each case list twice, for non-defaults and defaults
 	nodep->iterateChildren(*this);
@@ -233,7 +233,7 @@ private:
 	}
     }
 
-    virtual void visit(AstPragma* nodep, AstNUser*) {
+    virtual void visit(AstPragma* nodep) {
 	if (nodep->pragType() == AstPragmaType::PUBLIC_MODULE) {
 	    if (!m_modp) nodep->v3fatalSrc("PUBLIC_MODULE not under a module\n");
 	    m_modp->modPublic(true);
@@ -354,27 +354,27 @@ private:
 	if (filep && filep->varp()) filep->varp()->attrFileDescr(true);
     }
 
-    virtual void visit(AstFOpen* nodep, AstNUser*) {
+    virtual void visit(AstFOpen* nodep) {
 	nodep->iterateChildren(*this);
 	expectDescriptor(nodep, nodep->filep()->castNodeVarRef());
     }
-    virtual void visit(AstFClose* nodep, AstNUser*) {
+    virtual void visit(AstFClose* nodep) {
 	nodep->iterateChildren(*this);
 	expectDescriptor(nodep, nodep->filep()->castNodeVarRef());
     }
-    virtual void visit(AstFEof* nodep, AstNUser*) {
+    virtual void visit(AstFEof* nodep) {
 	nodep->iterateChildren(*this);
 	expectDescriptor(nodep, nodep->filep()->castNodeVarRef());
     }
-    virtual void visit(AstFScanF* nodep, AstNUser*) {
+    virtual void visit(AstFScanF* nodep) {
 	nodep->iterateChildren(*this);
 	expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstSScanF* nodep, AstNUser*) {
+    virtual void visit(AstSScanF* nodep) {
 	nodep->iterateChildren(*this);
 	expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	nodep->iterateChildren(*this);
 	string newFormat = expectFormat(nodep, nodep->text(), nodep->exprsp(), false);
 	nodep->text(newFormat);
@@ -383,11 +383,11 @@ private:
 	    nodep->scopeNamep(new AstScopeName(nodep->fileline()));
 	}
     }
-    virtual void visit(AstDisplay* nodep, AstNUser* vup) {
+    virtual void visit(AstDisplay* nodep) {
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstUdpTable* nodep, AstNUser*) {
+    virtual void visit(AstUdpTable* nodep) {
 	UINFO(5,"UDPTABLE  "<<nodep<<endl);
 	if (!v3Global.opt.bboxUnsup()) {
 	    // We don't warn until V3Inst, so that UDPs that are in libraries and
@@ -414,23 +414,23 @@ private:
 	}
     }
 
-    virtual void visit(AstScCtor* nodep, AstNUser*) {
+    virtual void visit(AstScCtor* nodep) {
 	// Constructor info means the module must remain public
 	m_modp->modPublic(true);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScDtor* nodep, AstNUser*) {
+    virtual void visit(AstScDtor* nodep) {
 	// Destructor info means the module must remain public
 	m_modp->modPublic(true);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScInt* nodep, AstNUser*) {
+    virtual void visit(AstScInt* nodep) {
 	// Special class info means the module must remain public
 	m_modp->modPublic(true);
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -466,24 +466,24 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Iterate modules backwards, in bottom-up order.
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	// Parent module inherits child's publicity
 	if (nodep->modp()->modPublic()) m_modp->modPublic(true);
 	//** No iteration for speed
     }
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	// Speedup
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
diff --git a/src/V3Localize.cpp b/src/V3Localize.cpp
index b8af31ac9..36d67673a 100644
--- a/src/V3Localize.cpp
+++ b/src/V3Localize.cpp
@@ -81,14 +81,14 @@ private:
     // See above
 
     // METHODS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	VarFlags flags (nodep->varp());
 	if (flags.m_done) {
 	    nodep->hiername("");	// Remove thisp->
 	    nodep->hierThis(true);
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -155,11 +155,11 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	nodep->iterateChildren(*this);
 	moveVars();
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	UINFO(4,"  CFUNC "<<nodep<<endl);
 	m_cfuncp = nodep;
 	searchFuncStmts(nodep->argsp());
@@ -190,7 +190,7 @@ private:
 	}
     }
 
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	if (!nodep->isSigPublic()
 	    && !nodep->isPrimaryIO()
 	    && !m_cfuncp) {	// Not already inside a function
@@ -199,7 +199,7 @@ private:
 	}
 	// No iterate; Don't want varrefs under it
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (!VarFlags(nodep->varp()).m_notOpt) {
 	    if (!m_cfuncp) {	// Not in function, can't optimize
 		clearOptimizable(nodep->varp(), "BVnofunc");
@@ -228,7 +228,7 @@ private:
 	}
 	// No iterate; Don't want varrefs under it
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Name.cpp b/src/V3Name.cpp
index 876a2a9c5..30107d68e 100644
--- a/src/V3Name.cpp
+++ b/src/V3Name.cpp
@@ -76,50 +76,50 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
     // Add __PVT__ to names of local signals
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	// Don't iterate... Don't need temps for RANGES under the Var.
 	rename(nodep, (!m_modp->isTop()
 		       && !nodep->isSigPublic()
 		       && !nodep->isFuncLocal()	// Isn't exposed, and would mess up dpi import wrappers
 		       && !nodep->isTemp()));	// Don't bother to rename internal signals
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	if (!nodep->user1()) {
 	    nodep->iterateChildren(*this);
 	    rename(nodep, false);
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()) {
 	    nodep->varp()->iterate(*this);
 	    nodep->name(nodep->varp()->name());
 	}
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	if (!nodep->user1()) {
 	    rename(nodep, !nodep->modp()->modPublic());
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstMemberDType* nodep, AstNUser*) {
+    virtual void visit(AstMemberDType* nodep) {
 	if (!nodep->user1()) {
 	    rename(nodep, false);
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstMemberSel* nodep, AstNUser*) {
+    virtual void visit(AstMemberSel* nodep) {
 	if (!nodep->user1()) {
 	    rename(nodep, false);
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	if (!nodep->user1SetOnce()) {
 	    if (nodep->aboveScopep()) nodep->aboveScopep()->iterate(*this);
 	    if (nodep->aboveCellp()) nodep->aboveCellp()->iterate(*this);
@@ -132,7 +132,7 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Order.cpp b/src/V3Order.cpp
index f3ba911b5..e610e4576 100644
--- a/src/V3Order.cpp
+++ b/src/V3Order.cpp
@@ -270,10 +270,10 @@ private:
 	return level;
     }
 
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	m_hasClk = false;
 	if (AstVarRef* varrefp = nodep->rhsp()->castVarRef()) {
-	    this->visit(varrefp, NULL);
+	    this->visit(varrefp);
 	    m_rightClkWidth = varrefp->width();
 	    if (varrefp->varp()->attrClocker() == AstVarAttrClocker::CLOCKER_YES) {
 		if (m_inClocked) {
@@ -309,7 +309,7 @@ private:
 	}
     }
 
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (m_inAss && nodep->varp()->attrClocker() == AstVarAttrClocker::CLOCKER_YES) {
 	    if (m_inClocked) {
 		nodep->v3warn(CLKDATA, "Clock used as data (on rhs of assignment) in sequential block "<<nodep->prettyName());
@@ -320,7 +320,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstConcat* nodep, AstNUser*) {
+    virtual void visit(AstConcat* nodep) {
 	if (m_inAss) {
 	    nodep->lhsp()->iterateAndNext(*this);
 	    int lw = m_childClkWidth;
@@ -329,20 +329,20 @@ private:
 	    m_childClkWidth = lw + rw;  // Pass up
 	}
     }
-    virtual void visit(AstNodeSel* nodep, AstNUser*) {
+    virtual void visit(AstNodeSel* nodep) {
 	if (m_inAss) {
 	    nodep->iterateChildren(*this);
 	    // Pass up result width
 	    if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
 	}
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	if (m_inAss) {
 	    nodep->iterateChildren(*this);
 	    if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
 	}
     }
-    virtual void visit(AstReplicate* nodep, AstNUser*) {
+    virtual void visit(AstReplicate* nodep) {
 	if (m_inAss) {
 	    nodep->iterateChildren(*this);
 	    if (nodep->rhsp()->castConst()) {
@@ -352,12 +352,12 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	m_inClocked = nodep->hasClocked();
 	nodep->iterateChildren(*this);
 	m_inClocked = false;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -390,7 +390,7 @@ private:
 	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
 	return level;
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	if (AstVarRef* varrefp = nodep->lhsp()->castVarRef() )
 	    if (varrefp->varp()->attrClocker() == AstVarAttrClocker::CLOCKER_YES) {
 		m_clkAss = true;
@@ -398,13 +398,13 @@ private:
 	    }
 	nodep->rhsp()->iterateChildren(*this);
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()->attrClocker() == AstVarAttrClocker::CLOCKER_YES) {
 	    m_clkAss = true;
 	    UINFO(6, "node was marked as clocker "<<nodep<<endl);
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -722,7 +722,7 @@ private:
 	}
     }
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	{
 	    AstUser4InUse	m_inuser4;	// Used only when building tree, so below
 	    nodep->iterateChildren(*this);
@@ -730,7 +730,7 @@ private:
 	// We're finished, complete the topscopes
 	if (m_topScopep) { process(); m_topScopep=NULL; }
     }
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	// Process the last thing we're finishing
 	if (m_topScopep) nodep->v3fatalSrc("Only one topscope should ever be created");
 	UINFO(2,"  Loading tree...\n");
@@ -768,12 +768,12 @@ private:
 	AstNode::user3ClearTree();
 	AstNode::user4ClearTree();
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(4," SCOPE "<<nodep<<endl);
 	m_scopep = nodep;
 	m_logicVxp = NULL;
@@ -783,7 +783,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_scopep = NULL;
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Create required activation blocks and add to module
 	UINFO(4,"  ACTIVE  "<<nodep<<endl);
 	m_activep = nodep;
@@ -796,14 +796,14 @@ private:
 	nodep->iterateChildren(*this);
 	m_activep = NULL;
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	// Create links to all input signals
 	if (m_modp->isTop() && nodep->varp()->isInput()) {
 	    OrderVarVertex* varVxp = newVarUserVertex(nodep, WV_STD);
 	    new OrderEdge(&m_graph, m_inputsVxp, varVxp, WEIGHT_INPUT);
 	}
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	if (m_scopep) {
 	    AstVarScope* varscp = nodep->varScopep();
 	    if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
@@ -926,7 +926,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	// Having a node derived from the sentree isn't required for
 	// correctness, it mearly makes the graph better connected
 	// and improves graph algorithmic performance
@@ -941,27 +941,27 @@ private:
 	    m_inSenTree = false;
 	}
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAlwaysPost* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPost* nodep) {
 	m_inPost = true;
 	iterateNewStmt(nodep);
 	m_inPost = false;
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	OrderClkAssVisitor visitor(nodep);
 	m_inClkAss = visitor.isClkAss();
 	iterateNewStmt(nodep);
 	m_inClkAss = false;
     }
-    virtual void visit(AstAssignPre* nodep, AstNUser*) {
+    virtual void visit(AstAssignPre* nodep) {
 	OrderClkAssVisitor visitor(nodep);
 	m_inClkAss = visitor.isClkAss();
 	m_inPre = true;
@@ -969,7 +969,7 @@ private:
 	m_inPre = false;
 	m_inClkAss = false;
     }
-    virtual void visit(AstAssignPost* nodep, AstNUser*) {
+    virtual void visit(AstAssignPost* nodep) {
 	OrderClkAssVisitor visitor(nodep);
 	m_inClkAss = visitor.isClkAss();
 	m_inPost = true;
@@ -977,15 +977,15 @@ private:
 	m_inPost = false;
 	m_inClkAss = false;
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	// We use initials to setup parameters and static consts's which may be referenced
 	// in user initial blocks.  So use ordering to sort them all out.
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstCFunc*, AstNUser*) {
+    virtual void visit(AstCFunc*) {
 	// Ignore for now
 	// We should detect what variables are set in the function, and make
 	// settlement code for them, then set a global flag, so we call "settle"
@@ -993,7 +993,7 @@ private:
     }
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Param.cpp b/src/V3Param.cpp
index 06ed3c395..ea9084074 100644
--- a/src/V3Param.cpp
+++ b/src/V3Param.cpp
@@ -238,11 +238,11 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Modules must be done in top-down-order
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	if (nodep->dead()) {
 	    UINFO(4," MOD-dead.  "<<nodep<<endl);  // Marked by LinkDot
 	} else if (nodep->level() <= 2  // Haven't added top yet, so level 2 is the top
@@ -256,13 +256,13 @@ private:
 	    UINFO(4," MOD-dead?  "<<nodep<<endl);  // Should have been done by now, if not dead
 	}
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	// Must do ifaces first, so push to list and do in proper order
 	m_cellps.push_back(nodep);
     }
 
     // Make sure all parameters are constantified
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	if (!nodep->user5SetOnce()) {  // Process once
 	    nodep->iterateChildren(*this);
 	    if (nodep->isParam()) {
@@ -280,14 +280,14 @@ private:
 	}
     }
     // Make sure varrefs cause vars to constify before things above
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()) nodep->varp()->iterate(*this);
     }
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	nodep->varp(NULL);  // Needs relink, as may remove pointed-to var
     }
 
-    virtual void visit(AstUnlinkedRef* nodep, AstNUser*) {
+    virtual void visit(AstUnlinkedRef* nodep) {
 	AstVarXRef* varxrefp = nodep->op1p()->castVarXRef();
 	AstNodeFTaskRef* taskrefp = nodep->op1p()->castNodeFTaskRef();
 	if (varxrefp) {
@@ -308,7 +308,7 @@ private:
 	nodep->replaceWith(nodep->op1p()->unlinkFrBack());
 	pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstCellArrayRef* nodep, AstNUser*) {
+    virtual void visit(AstCellArrayRef* nodep) {
 	V3Const::constifyParamsEdit(nodep->selp());
 	if (AstConst* constp = nodep->selp()->castConst()) {
 	    string index = AstNode::encodeNumber(constp->toSInt());
@@ -326,7 +326,7 @@ private:
     }
 
     // Generate Statements
-    virtual void visit(AstGenerate* nodep, AstNUser*) {
+    virtual void visit(AstGenerate* nodep) {
 	if (debug()>=9) nodep->dumpTree(cout,"-genin: ");
 	nodep->iterateChildren(*this);
 	// After expanding the generate, all statements under it can be moved
@@ -340,7 +340,7 @@ private:
 	}
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstGenIf* nodep, AstNUser*) {
+    virtual void visit(AstGenIf* nodep) {
 	UINFO(9,"  GENIF "<<nodep<<endl);
 	nodep->condp()->iterateAndNext(*this);
 	// We suppress errors when widthing params since short-circuiting in
@@ -370,7 +370,7 @@ private:
     //! @todo Unlike generated IF, we don't have to worry about short-circuiting the conditional
     //!       expression, since this is currently restricted to simple comparisons. If we ever do
     //!       move to more generic constant expressions, such code will be needed here.
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	if (nodep->genforp()) {
 	    AstGenFor* forp = nodep->genforp()->castGenFor();
 	    if (!forp) nodep->v3fatalSrc("Non-GENFOR under generate-for BEGIN");
@@ -398,10 +398,10 @@ private:
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstGenFor* nodep, AstNUser*) {
+    virtual void visit(AstGenFor* nodep) {
 	nodep->v3fatalSrc("GENFOR should have been wrapped in BEGIN");
     }
-    virtual void visit(AstGenCase* nodep, AstNUser*) {
+    virtual void visit(AstGenCase* nodep) {
 	UINFO(9,"  GENCASE "<<nodep<<endl);
 	AstNode* keepp = NULL;
 	nodep->exprp()->iterateAndNext(*this);
@@ -451,7 +451,7 @@ private:
     }
 
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Premit.cpp b/src/V3Premit.cpp
index 79c22f86a..c52be6106 100644
--- a/src/V3Premit.cpp
+++ b/src/V3Premit.cpp
@@ -61,14 +61,14 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
         //AstNode::user4ClearTree();  // Implied by AstUser4InUse
 	// LHS first as fewer varrefs
 	nodep->lhsp()->iterateAndNext(*this);
 	// Now find vars marked as lhs
 	nodep->rhsp()->iterateAndNext(*this);
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// it's LHS var is used so need a deep temporary
 	if (nodep->lvalue()) {
 	    nodep->varp()->user4(true);
@@ -79,7 +79,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -205,14 +205,14 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_funcp = NULL;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	m_funcp = nodep;
 	nodep->iterateChildren(*this);
 	m_funcp = NULL;
@@ -221,7 +221,7 @@ private:
 	m_assignLhs = false;
 	if (m_funcp) m_stmtp = nodep;
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	UINFO(4,"  WHILE  "<<nodep<<endl);
 	startStatement(nodep);
 	nodep->precondsp()->iterateAndNext(*this);
@@ -234,7 +234,7 @@ private:
 	nodep->incsp()->iterateAndNext(*this);
 	m_stmtp = NULL;
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	startStatement(nodep);
 	{
 	    bool noopt = PremitAssignVisitor(nodep).noOpt();
@@ -250,13 +250,13 @@ private:
 	m_assignLhs = false;
 	m_stmtp = NULL;
     }
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	UINFO(4,"  STMT  "<<nodep<<endl);
 	startStatement(nodep);
 	nodep->iterateChildren(*this);
 	m_stmtp = NULL;
     }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) {
+    virtual void visit(AstTraceInc* nodep) {
 	startStatement(nodep);
 	m_inTracep = nodep;
 	nodep->iterateChildren(*this);
@@ -310,25 +310,25 @@ private:
 	}
 	nodep->iterateChildren(*this); checkNode(nodep);
     }
-    virtual void visit(AstShiftL* nodep, AstNUser*) {
+    virtual void visit(AstShiftL* nodep) {
 	visitShift(nodep);
     }
-    virtual void visit(AstShiftR* nodep, AstNUser*) {
+    virtual void visit(AstShiftR* nodep) {
 	visitShift(nodep);
     }
-    virtual void visit(AstShiftRS* nodep, AstNUser*) {
+    virtual void visit(AstShiftRS* nodep) {
 	visitShift(nodep);
     }
     // Operators
-    virtual void visit(AstNodeTermop* nodep, AstNUser*) {
+    virtual void visit(AstNodeTermop* nodep) {
 	nodep->iterateChildren(*this); checkNode(nodep); }
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	nodep->iterateChildren(*this); checkNode(nodep); }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	nodep->iterateChildren(*this); checkNode(nodep); }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	nodep->iterateChildren(*this); checkNode(nodep); }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	nodep->fromp()->iterateAndNext(*this);
 	{   // Only the 'from' is part of the assignment LHS
 	    bool prevAssign = m_assignLhs;
@@ -338,9 +338,9 @@ private:
 	    m_assignLhs = prevAssign;
 	}
 	checkNode(nodep); }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	nodep->iterateChildren(*this); checkNode(nodep); }
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	nodep->iterateChildren(*this);
 	if (nodep->expr1p()->isWide()
 	    && !nodep->condp()->castConst()
@@ -353,7 +353,7 @@ private:
     }
 
     // Autoflush
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstDisplay* nodep) {
 	startStatement(nodep);
 	nodep->iterateChildren(*this);
 	m_stmtp = NULL;
@@ -371,7 +371,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	nodep->iterateChildren(*this);
 	// Any strings sent to a display must be var of string data type,
 	// to avoid passing a pointer to a temporary.
@@ -385,8 +385,8 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar* nodep, AstNUser*) {}	// Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {}	// Don't hit varrefs under vars
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Scope.cpp b/src/V3Scope.cpp
index 3498e568a..788e6f7b1 100644
--- a/src/V3Scope.cpp
+++ b/src/V3Scope.cpp
@@ -90,7 +90,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	AstNodeModule* modp = nodep->topModulep();
 	if (!modp) { nodep->v3error("No root module specified"); return; }
 	// Operate starting at the top of the hierarchy
@@ -99,7 +99,7 @@ private:
 	modp->accept(*this);
 	cleanupVarRefs();
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Create required blocks and add to module
 	string scopename;
 	if (!m_aboveScopep) scopename = "TOP";
@@ -149,10 +149,10 @@ private:
 
 	// ***Note m_scopep is passed back to the caller of the routine (above)
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	nodep->v3fatalSrc("Actives now made after scoping");
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstInitial* clonep = nodep->cloneTree(false);
@@ -160,7 +160,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstFinal* clonep = nodep->cloneTree(false);
@@ -168,7 +168,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstNode* clonep = nodep->cloneTree(false);
@@ -176,7 +176,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstAssignVarScope* nodep, AstNUser*) {
+    virtual void visit(AstAssignVarScope* nodep) {
 	// Copy under the scope but don't recurse
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstNode* clonep = nodep->cloneTree(false);
@@ -184,7 +184,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstNode* clonep = nodep->cloneTree(false);
@@ -192,7 +192,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstNode* clonep = nodep->cloneTree(false);
@@ -200,7 +200,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstNode* clonep = nodep->cloneTree(false);
@@ -208,7 +208,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    Move "<<nodep<<endl);
 	AstNode* clonep = nodep->cloneTree(false);
@@ -216,7 +216,7 @@ private:
 	m_scopep->addActivep(clonep);
 	clonep->iterateChildren(*this);	// We iterate under the *clone*
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    CFUNC "<<nodep<<endl);
 	AstCFunc* clonep = nodep->cloneTree(false);
@@ -226,7 +226,7 @@ private:
 	// We iterate under the *clone*
 	clonep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	// Add to list of blocks under this scope
 	UINFO(4,"    FTASK "<<nodep<<endl);
 	AstNodeFTask* clonep = nodep->cloneTree(false);
@@ -235,7 +235,7 @@ private:
 	// We iterate under the *clone*
 	clonep->iterateChildren(*this);
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	// Make new scope variable
 	// This is called cross-module by AstVar, so we cannot trust any m_ variables
 	if (!nodep->user1p()) {
@@ -254,7 +254,7 @@ private:
 	    m_scopep->addVarp(varscp);
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// VarRef needs to point to VarScope
 	// Make sure variable has made user1p.
 	if (!nodep->varp()) nodep->v3fatalSrc("Unlinked");
@@ -267,7 +267,7 @@ private:
 	    m_varRefScopes.insert(make_pair(nodep, m_scopep));
 	} 
    }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
 	// If there's a %m in the display text, we add a special node that will contain the name()
 	string prefix = (string)("__DOT__")+m_scopep->name();
 	// TOP and above will be the user's name().
@@ -283,13 +283,13 @@ private:
 	if (afterp) nodep->scopeEntrp(afterp);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// Scope that was made by this module for different cell;
 	// Want to ignore blocks under it, so just do nothing
     }
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -321,7 +321,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// Want to ignore blocks under it
 	m_scopep = nodep;
 	nodep->iterateChildren(*this);
@@ -340,42 +340,42 @@ private:
 	}
     }
 
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstAssignVarScope* nodep, AstNUser*) {
+    virtual void visit(AstAssignVarScope* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	movedDeleteOrIterate(nodep);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	movedDeleteOrIterate(nodep);
     }
 
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	// The crossrefs are dealt with in V3LinkDot
 	nodep->varp(NULL);
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	// The crossrefs are dealt with in V3LinkDot
 	UINFO(9,"   Old pkg-taskref "<<nodep<<endl);
 	if (nodep->packagep()) {
@@ -391,7 +391,7 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstModportFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstModportFTaskRef* nodep) {
 	// The crossrefs are dealt with in V3LinkDot
 	nodep->ftaskp(NULL);
 	nodep->iterateChildren(*this);
@@ -399,7 +399,7 @@ private:
 
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3SenTree.h b/src/V3SenTree.h
index 7e670b320..640bbffc9 100644
--- a/src/V3SenTree.h
+++ b/src/V3SenTree.h
@@ -62,31 +62,31 @@ private:
 	return level;
     }
 
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	// Only do the top
 	if (nodep->isTop()) {
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	m_topscopep = nodep;
 	nodep->iterateChildren(*this);
 	// Don't clear topscopep, the namer persists beyond this visit
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// But no SenTrees under TopScope's scope
     }
     // Memorize existing block names
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Don't grab SenTrees under Actives, only those that are global (under Scope directly)
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	m_treesp.push_back(nodep);
     }
     // Empty visitors, speed things up
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) { }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) { }
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
     // METHODS
diff --git a/src/V3Simulate.h b/src/V3Simulate.h
index 34e83b8b9..8fbae4f3a 100644
--- a/src/V3Simulate.h
+++ b/src/V3Simulate.h
@@ -244,15 +244,15 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	if (jumpingOver(nodep)) return;
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	// Sensitivities aren't inputs per se; we'll keep our tree under the same sens.
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (jumpingOver(nodep)) return;
 	if (!optimizable()) return;  // Accelerate
 	nodep->varp()->iterateChildren(*this);
@@ -311,19 +311,19 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstVarXRef* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
 	if (jumpingOver(nodep)) return;
 	if (m_scoped) {  badNodeType(nodep); return; }
 	else { clearOptimizable(nodep,"Language violation: Dotted hierarchical references not allowed in constant functions"); }
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	if (jumpingOver(nodep)) return;
 	if (!m_params) { badNodeType(nodep); return; }
 	if (nodep->dpiImport()) { clearOptimizable(nodep,"DPI import functions aren't simulatable"); }
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	if (jumpingOver(nodep)) return;
 	UINFO(5,"   IF "<<nodep<<endl);
 	checkNodeInfo(nodep);
@@ -340,13 +340,13 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	checkNodeInfo(nodep);
 	if (!m_checkOnly && optimizable()) {
 	    setNumber(nodep, &(nodep->num()));
 	}
     }
-    virtual void visit(AstEnumItemRef* nodep, AstNUser*) {
+    virtual void visit(AstEnumItemRef* nodep) {
 	checkNodeInfo(nodep);
 	if (!nodep->itemp()) nodep->v3fatalSrc("Not linked");
 	if (!m_checkOnly && optimizable()) {
@@ -359,7 +359,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	if (!optimizable()) return;  // Accelerate
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
@@ -367,7 +367,7 @@ private:
 	    nodep->numberOperate(*newNumber(nodep), *fetchNumber(nodep->lhsp()));
 	}
     }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	if (!optimizable()) return;  // Accelerate
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
@@ -375,7 +375,7 @@ private:
 	    nodep->numberOperate(*newNumber(nodep), *fetchNumber(nodep->lhsp()), *fetchNumber(nodep->rhsp()));
 	}
     }
-    virtual void visit(AstNodeTriop* nodep, AstNUser*) {
+    virtual void visit(AstNodeTriop* nodep) {
 	if (!optimizable()) return;  // Accelerate
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
@@ -386,7 +386,7 @@ private:
 				 *fetchNumber(nodep->thsp()));
 	}
     }
-    virtual void visit(AstLogAnd* nodep, AstNUser*) {
+    virtual void visit(AstLogAnd* nodep) {
 	// Need to short circuit
 	if (!optimizable()) return;  // Accelerate
 	checkNodeInfo(nodep);
@@ -402,7 +402,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstLogOr* nodep, AstNUser*) {
+    virtual void visit(AstLogOr* nodep) {
 	// Need to short circuit
 	if (!optimizable()) return;  // Accelerate
 	checkNodeInfo(nodep);
@@ -418,7 +418,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstLogIf* nodep, AstNUser*) {
+    virtual void visit(AstLogIf* nodep) {
 	// Need to short circuit, same as (!A || B)
 	if (!optimizable()) return;  // Accelerate
 	checkNodeInfo(nodep);
@@ -434,7 +434,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	// We could use above visit(AstNodeTriop), but need to do short circuiting.
 	// It's also slower even O(n^2) to evaluate both sides when we really only need to evaluate one side.
 	if (!optimizable()) return;  // Accelerate
@@ -501,7 +501,7 @@ private:
 	return true;
     }
 
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	if (jumpingOver(nodep)) return;
 	if (!optimizable()) return;  // Accelerate
 	if (nodep->castAssignDly()) {
@@ -532,11 +532,11 @@ private:
 	}
 	m_inDlyAssign = false;
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeCase* nodep, AstNUser*) {
+    virtual void visit(AstNodeCase* nodep) {
 	if (jumpingOver(nodep)) return;
 	UINFO(5,"   CASE "<<nodep<<endl);
 	checkNodeInfo(nodep);
@@ -572,16 +572,16 @@ private:
 	}
     }
 
-    virtual void visit(AstCaseItem* nodep, AstNUser*) {
+    virtual void visit(AstCaseItem* nodep) {
 	// Real handling is in AstNodeCase
 	if (jumpingOver(nodep)) return;
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstComment*, AstNUser*) {}
+    virtual void visit(AstComment*) {}
 
-    virtual void visit(AstJumpGo* nodep, AstNUser*) {
+    virtual void visit(AstJumpGo* nodep) {
 	if (jumpingOver(nodep)) return;
 	checkNodeInfo(nodep);
 	if (!m_checkOnly) {
@@ -589,7 +589,7 @@ private:
 	    m_jumpp = nodep;
 	}
     }
-    virtual void visit(AstJumpLabel* nodep, AstNUser*) {
+    virtual void visit(AstJumpLabel* nodep) {
 	if (jumpingOver(nodep)) return;
 	checkNodeInfo(nodep);
 	nodep->iterateChildren(*this);
@@ -598,7 +598,7 @@ private:
 	    m_jumpp = NULL;
 	}
     }
-    virtual void visit(AstStop* nodep, AstNUser*) {
+    virtual void visit(AstStop* nodep) {
 	if (jumpingOver(nodep)) return;
 	if (m_params) {  // This message seems better than an obscure $stop
 	    // The spec says $stop is just ignored, it seems evil to ignore assertions
@@ -607,7 +607,7 @@ private:
 	checkNodeInfo(nodep);
     }
 
-    virtual void visit(AstNodeFor* nodep, AstNUser*) {
+    virtual void visit(AstNodeFor* nodep) {
 	// Doing lots of Whiles is slow, so only for parameters
 	UINFO(5,"   FOR "<<nodep<<endl);
 	if (!m_params) { badNodeType(nodep); return; }
@@ -634,7 +634,7 @@ private:
 	}
     }
 
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	// Doing lots of Whiles is slow, so only for parameters
 	if (jumpingOver(nodep)) return;
 	UINFO(5,"   WHILE "<<nodep<<endl);
@@ -668,7 +668,7 @@ private:
 	}
     }
 
-    virtual void visit(AstFuncRef* nodep, AstNUser*) {
+    virtual void visit(AstFuncRef* nodep) {
 	if (jumpingOver(nodep)) return;
 	UINFO(5,"   FUNCREF "<<nodep<<endl);
 	if (!m_params) { badNodeType(nodep); return; }
@@ -710,12 +710,12 @@ private:
 	}
     }
 
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	if (jumpingOver(nodep)) return;
 	if (!m_params) { badNodeType(nodep); return; }
     }
 
-    virtual void visit(AstSFormatF *nodep, AstNUser*) {
+    virtual void visit(AstSFormatF *nodep) {
 	if (jumpingOver(nodep)) return;
 	nodep->iterateChildren(*this);
 	if (m_params) {
@@ -759,7 +759,7 @@ private:
 	}
     }
 
-    virtual void visit(AstDisplay *nodep, AstNUser*) {
+    virtual void visit(AstDisplay *nodep) {
 	if (jumpingOver(nodep)) return;
 	nodep->iterateChildren(*this);
 	if (m_params) {
@@ -788,7 +788,7 @@ private:
     // These types are definately not reducable
     //   AstCoverInc, AstArraySel, AstFinish,
     //   AstRand, AstTime, AstUCFunc, AstCCall, AstCStmt, AstUCStmt
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	if (jumpingOver(nodep)) return;
 	badNodeType(nodep);
     }
diff --git a/src/V3Slice.cpp b/src/V3Slice.cpp
index 314f79fa4..20f138781 100644
--- a/src/V3Slice.cpp
+++ b/src/V3Slice.cpp
@@ -68,7 +68,7 @@ class SliceCloneVisitor : public AstNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	if (!nodep->backp()->castArraySel()) {
 	    // This is the top of an ArraySel, setup for iteration
 	    m_refp = nodep->user1p()->castNode()->castVarRef();
@@ -118,7 +118,7 @@ class SliceCloneVisitor : public AstNVisitor {
 	nodep->length(1);
     }
 
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	if (nodep->user2() < 2) return; // Don't need clones
 	m_selBits.clear();
 	UINFO(4, "Cloning "<<nodep->user2()<<" times: "<<nodep<<endl);
@@ -168,20 +168,20 @@ class SliceCloneVisitor : public AstNVisitor {
 	nodep->replaceWith(lhsp);
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstRedOr* nodep, AstNUser*) {
+    virtual void visit(AstRedOr* nodep) {
 	cloneUniop(nodep);
     }
-    virtual void visit(AstRedAnd* nodep, AstNUser*) {
+    virtual void visit(AstRedAnd* nodep) {
 	cloneUniop(nodep);
     }
-    virtual void visit(AstRedXor* nodep, AstNUser*) {
+    virtual void visit(AstRedXor* nodep) {
 	cloneUniop(nodep);
     }
-    virtual void visit(AstRedXnor* nodep, AstNUser*) {
+    virtual void visit(AstRedXnor* nodep) {
 	cloneUniop(nodep);
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -289,7 +289,7 @@ class SliceVisitor : public AstNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// The LHS/RHS of an Assign may be to a Var that is an array. In this
 	// case we need to create a slice across the entire Var
 	if (m_assignp && !nodep->backp()->castArraySel()) {
@@ -305,7 +305,7 @@ class SliceVisitor : public AstNVisitor {
 	}
     }
 
-    virtual void visit(AstExtend* nodep, AstNUser*) {
+    virtual void visit(AstExtend* nodep) {
 	m_extend = true;
 	if (m_assignp && m_assignp->user2() > 1 && !m_assignError) {
 	    m_assignp->v3error("Unsupported: Assignment between unpacked arrays of different dimensions");
@@ -314,7 +314,7 @@ class SliceVisitor : public AstNVisitor {
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	m_extend = true;
 	if (m_assignp && m_assignp->user2() > 1 && !m_assignError) {
 	    m_assignp->v3error("Unsupported: Assignment between a constant and an array slice");
@@ -322,7 +322,7 @@ class SliceVisitor : public AstNVisitor {
 	}
     }
 
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	if (!m_assignp) return;
 	if (nodep->user3()) return;  // Prevent recursion on just created nodes
 	unsigned dim = explicitDimensions(nodep);
@@ -352,7 +352,7 @@ class SliceVisitor : public AstNVisitor {
 	}
     }
 
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	m_extend = true;
 	if (m_assignp && m_assignp->user2() > 1 && !m_assignError) {
 	    m_assignp->v3error("Unsupported: Assignment between unpacked arrays of different dimensions");
@@ -361,7 +361,7 @@ class SliceVisitor : public AstNVisitor {
 	nodep->iterateChildren(*this);
     }
 
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	// The conditional must be a single bit so only look at the expressions
 	nodep->expr1p()->accept(*this);
 	nodep->expr2p()->accept(*this);
@@ -412,7 +412,7 @@ class SliceVisitor : public AstNVisitor {
 	m_assignp = NULL;
     }
 
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	if (!nodep->user1()) {
 	    // Cleanup initArrays
 	    if (AstInitArray* initp = nodep->rhsp()->castInitArray()) {
@@ -458,16 +458,16 @@ class SliceVisitor : public AstNVisitor {
 	    }
 	}
     }
-    virtual void visit(AstRedOr* nodep, AstNUser*) {
+    virtual void visit(AstRedOr* nodep) {
 	expandUniOp(nodep);
     }
-    virtual void visit(AstRedAnd* nodep, AstNUser*) {
+    virtual void visit(AstRedAnd* nodep) {
 	expandUniOp(nodep);
     }
-    virtual void visit(AstRedXor* nodep, AstNUser*) {
+    virtual void visit(AstRedXor* nodep) {
 	expandUniOp(nodep);
     }
-    virtual void visit(AstRedXnor* nodep, AstNUser*) {
+    virtual void visit(AstRedXnor* nodep) {
 	expandUniOp(nodep);
     }
 
@@ -514,20 +514,20 @@ class SliceVisitor : public AstNVisitor {
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstEq* nodep, AstNUser*) {
+    virtual void visit(AstEq* nodep) {
 	expandBiOp(nodep);
     }
-    virtual void visit(AstNeq* nodep, AstNUser*) {
+    virtual void visit(AstNeq* nodep) {
 	expandBiOp(nodep);
     }
-    virtual void visit(AstEqCase* nodep, AstNUser*) {
+    virtual void visit(AstEqCase* nodep) {
 	expandBiOp(nodep);
     }
-    virtual void visit(AstNeqCase* nodep, AstNUser*) {
+    virtual void visit(AstNeqCase* nodep) {
 	expandBiOp(nodep);
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
diff --git a/src/V3Split.cpp b/src/V3Split.cpp
index 77c437467..59535a90d 100644
--- a/src/V3Split.cpp
+++ b/src/V3Split.cpp
@@ -465,14 +465,14 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	UINFO(4,"   ALW   "<<nodep<<endl);
 	if (debug()>=9) nodep->dumpTree(cout,"   alwIn:: ");
 	scoreboardClear();
 	processBlock(nodep->bodysp());
 	if (debug()>=9) nodep->dumpTree(cout,"   alwOut: ");
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	if (!m_reorder) {
 	    nodep->iterateChildren(*this);
 	} else {
@@ -485,13 +485,13 @@ private:
     // We don't do AstNodeFor/AstWhile loops, due to the standard question
     // of what is before vs. after
 
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	m_inDly = true;
 	UINFO(4,"    ASSIGNDLY "<<nodep<<endl);
 	nodep->iterateChildren(*this);
 	m_inDly = false;
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (!m_stmtStackps.empty()) {
 	    AstVarScope* vscp = nodep->varScopep();
 	    if (!vscp) nodep->v3fatalSrc("Not linked");
@@ -539,7 +539,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstJumpGo* nodep, AstNUser*) {
+    virtual void visit(AstJumpGo* nodep) {
 	// Jumps will disable reordering at all levels
 	// This is overly pessimistic; we could treat jumps as barriers, and
 	// reorder everything between jumps/labels, however jumps are rare
@@ -551,7 +551,7 @@ private:
 
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// **** SPECIAL default type that sets PLI_ORDERING
 	if (!m_stmtStackps.empty() && !nodep->isPure()) {
 	    UINFO(9,"         NotSplittable "<<nodep<<endl);
diff --git a/src/V3SplitAs.cpp b/src/V3SplitAs.cpp
index 66d06e0c7..b56ffe3cf 100644
--- a/src/V3SplitAs.cpp
+++ b/src/V3SplitAs.cpp
@@ -60,13 +60,13 @@ private:
     AstVarScope* m_splitVscp;	// Variable we want to split
 
     // METHODS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->lvalue() && !m_splitVscp
 	    && nodep->varp()->attrIsolateAssign()) {
 	    m_splitVscp = nodep->varScopep();
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -92,7 +92,7 @@ private:
     bool	 m_matches;	// Statement below has matching lvalue reference
 
     // METHODS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->lvalue()) {
 	    if (nodep->varScopep()==m_splitVscp) {
 		UINFO(6,"       CL VAR "<<nodep<<endl);
@@ -100,7 +100,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	UINFO(6,"     CL STMT "<<nodep<<endl);
 	bool oldKeep = m_keepStmt;
 	{
@@ -122,7 +122,7 @@ private:
 	m_keepStmt = oldKeep || m_keepStmt;
 	UINFO(9,"     upKeep="<<m_keepStmt<<" STMT "<<nodep<<endl);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -167,7 +167,7 @@ private:
 	}
     }
 
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	// Are there any lvalue references below this?
 	// There could be more than one.  So, we process the first one found first.
 	AstVarScope* lastSplitVscp = NULL;
@@ -192,9 +192,9 @@ private:
     }
 
     // Speedup; no always under math
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
+    virtual void visit(AstNodeMath* nodep) {}
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Stats.cpp b/src/V3Stats.cpp
index e2f19f79e..a09cd695d 100644
--- a/src/V3Stats.cpp
+++ b/src/V3Stats.cpp
@@ -78,7 +78,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	allNodes(nodep);
 	if (!m_fast) {
 	    nodep->iterateChildrenConst(*this);
@@ -95,7 +95,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	allNodes(nodep);
 	nodep->iterateChildrenConst(*this);
 	if (m_counting && nodep->dtypep()) {
@@ -118,7 +118,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	allNodes(nodep);
 	nodep->iterateChildrenConst(*this);
 	if (m_counting) {
@@ -127,7 +127,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	UINFO(4,"   IF "<<nodep<<endl);
 	allNodes(nodep);
 	// Condition is part of PREVIOUS block
@@ -175,9 +175,9 @@ private:
 	}
     }
     // While's we assume evaluate once.
-    //virtual void visit(AstWhile* nodep, AstNUser*) {
+    //virtual void visit(AstWhile* nodep) {
 
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	//UINFO(4,"  CCALL "<<nodep<<endl);
 	allNodes(nodep);
 	nodep->iterateChildrenConst(*this);
@@ -186,13 +186,13 @@ private:
 	    nodep->funcp()->accept(*this);
 	}
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	m_cfuncp = nodep;
 	allNodes(nodep);
 	nodep->iterateChildrenConst(*this);
 	m_cfuncp = NULL;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	allNodes(nodep);
 	nodep->iterateChildrenConst(*this);
     }
diff --git a/src/V3Subst.cpp b/src/V3Subst.cpp
index d0f198428..a8b17d349 100644
--- a/src/V3Subst.cpp
+++ b/src/V3Subst.cpp
@@ -195,7 +195,7 @@ private:
 	return (SubstVarEntry*)(nodep->varp()->user1p());  // Might be NULL
     }
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	SubstVarEntry* entryp = findEntryp (nodep);
 	if (entryp) {
 	    // Don't sweat it.  We assign a new temp variable for every new assignment,
@@ -208,8 +208,8 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {}	// Accelerate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {}	// Accelerate
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -263,7 +263,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	m_ops = 0;
 	m_assignStep++;
 	nodep->rhsp()->iterateAndNext(*this);
@@ -313,7 +313,7 @@ private:
 	pushDeletep(nodep); VL_DANGLING(nodep);
 	++m_statSubsts;
     }
-    virtual void visit(AstWordSel* nodep, AstNUser*) {
+    virtual void visit(AstWordSel* nodep) {
 	nodep->rhsp()->accept(*this);
 	AstVarRef* varrefp = nodep->lhsp()->castVarRef();
 	AstConst* constp = nodep->rhsp()->castConst();
@@ -340,7 +340,7 @@ private:
 	    nodep->lhsp()->accept(*this);
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// Any variable
 	if (nodep->lvalue()) {
 	    m_assignStep++;
@@ -368,9 +368,9 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {}
-    virtual void visit(AstConst* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {}
+    virtual void visit(AstConst* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	m_ops++;
 	if (!nodep->isSubstOptimizable()) {
 	    m_ops = SUBST_MAX_OPS_NA;
diff --git a/src/V3Table.cpp b/src/V3Table.cpp
index f50abda12..9a0a203f4 100644
--- a/src/V3Table.cpp
+++ b/src/V3Table.cpp
@@ -402,37 +402,37 @@ private:
 
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modTables = 0;
 	m_modTableVscs.clear();
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(4," SCOPE "<<nodep<<endl);
 	m_scopep = nodep;
 	nodep->iterateChildren(*this);
 	m_scopep = NULL;
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	UINFO(4,"  ALWAYS  "<<nodep<<endl);
 	if (treeTest(nodep)) {
 	    // Well, then, I'll be a memory hog.
 	    createTable(nodep); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {}
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {}
+    virtual void visit(AstAssignW* nodep) {
 	// It's nearly impossible to have a large enough assign to make this worthwhile
 	// For now we won't bother.
 	// Accelerated: no iterate
     }
     // default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Task.cpp b/src/V3Task.cpp
index 138ff8911..f2e6432ce 100644
--- a/src/V3Task.cpp
+++ b/src/V3Task.cpp
@@ -159,7 +159,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// Each FTask is unique per-scope, so AstNodeFTaskRefs do not need
 	// pointers to what scope the FTask is to be invoked under.
 	// However, to create variables, we need to track the scopes involved.
@@ -180,12 +180,12 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	m_assignwp = nodep;
 	nodep->iterateChildren(*this); VL_DANGLING(nodep);  // May delete nodep.
 	m_assignwp = NULL;
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	if (m_assignwp) {
 	    // Wire assigns must become always statements to deal with insertion
 	    // of multiple statements.  Perhaps someday make all wassigns into always's?
@@ -196,7 +196,7 @@ private:
 	if (!nodep->taskp()) nodep->v3fatalSrc("Unlinked task");
 	new TaskEdge (&m_callGraph, m_curVxp, getFTaskVertex(nodep->taskp()));
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	UINFO(9,"  TASK "<<nodep<<endl);
 	TaskBaseVertex* lastVxp = m_curVxp;
 	m_curVxp = getFTaskVertex(nodep);
@@ -204,7 +204,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_curVxp = lastVxp;
     }
-    virtual void visit(AstPragma* nodep, AstNUser*) {
+    virtual void visit(AstPragma* nodep) {
 	if (nodep->pragType() == AstPragmaType::NO_INLINE_TASK) {
 	    // Just mark for the next steps, and we're done with it.
 	    m_curVxp->noInline(true);
@@ -214,11 +214,11 @@ private:
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user4p(m_curVxp);  // Remember what task it's under
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (nodep->varp()->user4p() != m_curVxp) {
 	    if (m_curVxp->pure()
@@ -229,7 +229,7 @@ private:
     }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -258,7 +258,7 @@ private:
     //   AstVar::user2p		// AstVarScope* to replace varref with
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// Similar code in V3Inline
 	if (nodep->varp()->user2p()) { // It's being converted to a alias.
 	    UINFO(9, "    relinkVar "<<(void*)nodep->varp()->user2p()<<" "<<nodep<<endl);
@@ -272,7 +272,7 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -1021,24 +1021,24 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_insStmtp = NULL;
 	m_modNCalls = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	m_topScopep = nodep;
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	m_scopep = nodep;
 	m_insStmtp = NULL;
 	nodep->iterateChildren(*this);
 	m_scopep = NULL;
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	if (!nodep->taskp()) nodep->v3fatalSrc("Unlinked?");
 	iterateIntoFTask(nodep->taskp());	// First, do hierarchical funcs
 	UINFO(4," FTask REF   "<<nodep<<endl);
@@ -1077,7 +1077,7 @@ private:
 	nodep->deleteTree(); VL_DANGLING(nodep);
 	UINFO(4,"  FTask REF Done.\n");
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	UINFO(4," Inline   "<<nodep<<endl);
 	InsertMode prevInsMode = m_insMode;
 	AstNode* prevInsStmtp = m_insStmtp;
@@ -1130,7 +1130,7 @@ private:
 	m_insMode = prevInsMode;
 	m_insStmtp = prevInsStmtp;
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	// Special, as statements need to be put in different places
 	// Preconditions insert first just before themselves (the normal rule for other statement types)
 	m_insStmtp = NULL;	// First thing should be new statement
@@ -1146,10 +1146,10 @@ private:
 	// Done the loop
 	m_insStmtp = NULL;	// Next thing should be new statement
     }
-    virtual void visit(AstNodeFor* nodep, AstNUser*) {
+    virtual void visit(AstNodeFor* nodep) {
 	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin.cpp\n");
     }
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	m_insMode = IM_BEFORE;
 	m_insStmtp = nodep;
 	nodep->iterateChildren(*this);
@@ -1157,7 +1157,7 @@ private:
     }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Trace.cpp b/src/V3Trace.cpp
index 7bdf2b1b1..a3ac04aa2 100644
--- a/src/V3Trace.cpp
+++ b/src/V3Trace.cpp
@@ -557,7 +557,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	m_code = 1; 	// Multiple TopScopes will require fixing how code#s
 	// are assigned as duplicate varscopes must result in the same tracing code#.
 
@@ -585,17 +585,17 @@ private:
 	assignActivity();
 	putTracesIntoTree();
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	if (nodep->isTop()) m_topModp = nodep;
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	AstScope* scopep = nodep->scopep();
 	if (!scopep) nodep->v3fatalSrc("No scope found on top level");
 	m_highScopep = scopep;
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	UINFO(8,"   CCALL "<<nodep<<endl);
 	if (!m_finding && !nodep->user2()) {
 	    // See if there are other calls in same statement list;
@@ -613,7 +613,7 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	UINFO(8,"   CFUNC "<<nodep<<endl);
 	if (nodep->funcType() == AstCFuncType::TRACE_INIT) {
 	    m_initFuncp = nodep;
@@ -636,7 +636,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_funcp = NULL;
     }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) {
+    virtual void visit(AstTraceInc* nodep) {
 	UINFO(8,"   TRACE "<<nodep<<endl);
 	if (m_finding) nodep->v3fatalSrc("Traces should have been removed in prev step.");
 	nodep->unlinkFrBack();
@@ -649,7 +649,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_tracep = NULL;
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (m_tracep) {
 	    if (!nodep->varScopep()) nodep->v3fatalSrc("No var scope?");
 	    if (nodep->lvalue()) nodep->v3fatalSrc("Lvalue in trace?  Should be const.");
@@ -675,7 +675,7 @@ private:
 	}
     }
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp
index 7a8fb3096..56de2e5c1 100644
--- a/src/V3TraceDecl.cpp
+++ b/src/V3TraceDecl.cpp
@@ -137,7 +137,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	m_scopetopp = nodep->scopep();
 	// Make containers for TRACEDECLs first
 	m_initFuncp = newCFunc(AstCFuncType::TRACE_INIT, "traceInitThis", true);
@@ -148,7 +148,7 @@ private:
 	// And find variables
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	nodep->iterateChildren(*this);
 	// Avoid updating this if (), instead see varp->isTrace()
 	if (!nodep->varp()->isTemp() && !nodep->varp()->isFuncLocal()) {
@@ -183,17 +183,17 @@ private:
 	}
     }
     // VISITORS - Data types when tracing
-    virtual void visit(AstConstDType* nodep, AstNUser*) {
+    virtual void visit(AstConstDType* nodep) {
 	if (m_traVscp) {
 	    nodep->subDTypep()->skipRefp()->accept(*this);
 	}
     }
-    virtual void visit(AstRefDType* nodep, AstNUser*) {
+    virtual void visit(AstRefDType* nodep) {
 	if (m_traVscp) {
 	    nodep->subDTypep()->skipRefp()->accept(*this);
 	}
     }
-    virtual void visit(AstUnpackArrayDType* nodep, AstNUser*) {
+    virtual void visit(AstUnpackArrayDType* nodep) {
 	// Note more specific dtypes above
 	if (m_traVscp) {
 	    if ((int)nodep->arrayUnpackedElements() > v3Global.opt.traceMaxArray()) {
@@ -223,7 +223,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstPackArrayDType* nodep, AstNUser*) {
+    virtual void visit(AstPackArrayDType* nodep) {
 	if (m_traVscp) {
 	    if (!v3Global.opt.traceStructs()) {
 		// Everything downstream is packed, so deal with as one trace unit
@@ -248,7 +248,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeClassDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeClassDType* nodep) {
 	if (m_traVscp) {
 	    if (nodep->packed() && !v3Global.opt.traceStructs()) {
 		// Everything downstream is packed, so deal with as one trace unit
@@ -280,7 +280,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	if (m_traVscp) {
 	    if (nodep->keyword()==AstBasicDTypeKwd::STRING) {
 		addIgnore("Unsupported: strings");
@@ -289,14 +289,14 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeDType* nodep) {
 	// Note more specific dtypes above
 	if (!m_traVscp) return;
 	addIgnore("Unsupported: data type");
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Tristate.cpp b/src/V3Tristate.cpp
index a969b2722..5ef5dcfe6 100644
--- a/src/V3Tristate.cpp
+++ b/src/V3Tristate.cpp
@@ -286,7 +286,7 @@ class TristatePinVisitor : public TristateBaseVisitor {
     TristateGraph& m_tgraph;
     bool m_lvalue;	// Flip to be an LVALUE
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (m_lvalue && !nodep->lvalue()) {
 	    UINFO(9,"  Flip-to-LValue "<<nodep<<endl);
 	    nodep->lvalue(true);
@@ -298,12 +298,12 @@ class TristatePinVisitor : public TristateBaseVisitor {
 	    m_tgraph.setTristate(nodep->varp());
 	}
     }
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	// Doesn't work because we'd set lvalue on the array index's var
 	if (m_lvalue) nodep->v3fatalSrc("ArraySel conversion to output, under tristate node");
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -635,7 +635,7 @@ class TristateVisitor : public TristateBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	UINFO(9,dbgState()<<nodep<<endl);
 	if (m_graphing) {
 	    if (!m_alhs && nodep->num().hasZ()) {
@@ -668,7 +668,7 @@ class TristateVisitor : public TristateBaseVisitor {
 	}
     }
 
-    virtual void visit(AstCond* nodep, AstNUser*) {
+    virtual void visit(AstCond* nodep) {
 	if (m_graphing) {
 	    nodep->iterateChildren(*this);
 	    if (m_alhs) {
@@ -707,7 +707,7 @@ class TristateVisitor : public TristateBaseVisitor {
 	}
     }
 
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	if (m_graphing) {
 	    nodep->iterateChildren(*this);
 	    if (m_alhs) {
@@ -744,7 +744,7 @@ class TristateVisitor : public TristateBaseVisitor {
 	}
     }
 
-    virtual void visit(AstConcat* nodep, AstNUser*) {
+    virtual void visit(AstConcat* nodep) {
 	if (m_graphing) {
 	    nodep->iterateChildren(*this);
 	    if (m_alhs) {
@@ -793,7 +793,7 @@ class TristateVisitor : public TristateBaseVisitor {
 	}
     }
 
-    virtual void visit(AstBufIf1* nodep, AstNUser*) {
+    virtual void visit(AstBufIf1* nodep) {
 	// For BufIf1, the enable is the LHS expression
 	nodep->iterateChildren(*this);
 	UINFO(9,dbgState()<<nodep<<endl);
@@ -873,10 +873,10 @@ class TristateVisitor : public TristateBaseVisitor {
 	    expr2p->user1p(NULL);
 	}
     }
-    virtual void visit(AstAnd* nodep, AstNUser*) {
+    virtual void visit(AstAnd* nodep) {
 	visitAndOr(nodep,true);
     }
-    virtual void visit(AstOr* nodep, AstNUser*) {
+    virtual void visit(AstOr* nodep) {
 	visitAndOr(nodep,false);
     }
 
@@ -913,10 +913,10 @@ class TristateVisitor : public TristateBaseVisitor {
 	    m_alhs = false;
 	}
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	visitAssign(nodep);
     }
-    virtual void visit(AstAssign* nodep, AstNUser*) {
+    virtual void visit(AstAssign* nodep) {
 	visitAssign(nodep);
     }
 
@@ -964,20 +964,20 @@ class TristateVisitor : public TristateBaseVisitor {
 	nodep->lhsp()->iterateAndNext(*this);
 	if (nodep->lhsp()->user1p()) { nodep->v3error("Unsupported LHS tristate construct: "<<nodep->prettyTypeName()); return; }
     }
-    virtual void visit(AstEqCase* nodep, AstNUser*) {
+    virtual void visit(AstEqCase* nodep) {
 	visitCaseEq(nodep,false);
     }
-    virtual void visit(AstNeqCase* nodep, AstNUser*) {
+    virtual void visit(AstNeqCase* nodep) {
 	visitCaseEq(nodep,true);
     }
-    virtual void visit(AstEqWild* nodep, AstNUser*) {
+    virtual void visit(AstEqWild* nodep) {
 	visitEqNeqWild(nodep);
     }
-    virtual void visit(AstNeqWild* nodep, AstNUser*) {
+    virtual void visit(AstNeqWild* nodep) {
 	visitEqNeqWild(nodep);
     }
 
-    virtual void visit(AstPull* nodep, AstNUser*) {
+    virtual void visit(AstPull* nodep) {
 	UINFO(9,dbgState()<<nodep<<endl);
 	if (m_graphing) {
 	    if (AstVarRef* lhsp = nodep->lhsp()->castVarRef()) {
@@ -1046,7 +1046,7 @@ class TristateVisitor : public TristateBaseVisitor {
     //     const input	in(from-resolver-with-const-value), __en(from-resolver-const), __out(to-resolver-only)
     //     const inout	Spec says illegal
     //     const output	Unsupported; Illegal?
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	if (m_graphing) {
 	    if (nodep->user2() & U2_GRAPHING) return;  // This pin is already expanded
 	    nodep->user2(U2_GRAPHING);
@@ -1185,7 +1185,7 @@ class TristateVisitor : public TristateBaseVisitor {
 	}
     }
 
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	UINFO(9,dbgState()<<nodep<<endl);
 	if (m_graphing) {
 	    if (nodep->lvalue()) {
@@ -1219,7 +1219,7 @@ class TristateVisitor : public TristateBaseVisitor {
 	}
     }
 
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nodep->iterateChildren(*this);
 	UINFO(9,dbgState()<<nodep<<endl);
 	if (m_graphing) {
@@ -1251,7 +1251,7 @@ class TristateVisitor : public TristateBaseVisitor {
 	}
     }
 
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(8, nodep<<endl);
 	if (m_graphing) nodep->v3fatalSrc("Modules under modules not supported");  // Lots of per-module state breaks
 	// Clear state
@@ -1275,28 +1275,28 @@ class TristateVisitor : public TristateBaseVisitor {
 	m_modp = NULL;
     }
 
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	// don't deal with functions
     }
 
-    virtual void visit(AstCaseItem* nodep, AstNUser*) {
+    virtual void visit(AstCaseItem* nodep) {
 	// don't deal with casez compare '???? values
 	nodep->bodysp()->iterateAndNext(*this);
     }
 
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	m_cellp = nodep;
 	m_alhs = false;
 	nodep->iterateChildren(*this);
 	m_cellp = NULL;
     }
 
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	nodep->iterateChildrenBackwards(*this);
     }
 
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	checkUnhandled(nodep);
     }
diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp
index a687caa6b..f57e77750 100644
--- a/src/V3Undriven.cpp
+++ b/src/V3Undriven.cpp
@@ -266,7 +266,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	for (int usr=1; usr<(m_alwaysp?3:2); ++usr) {
 	    UndrivenVarEntry* entryp = getEntryp (nodep, usr);
 	    if (nodep->isInput()
@@ -284,11 +284,11 @@ private:
 	// Discover variables used in bit definitions, etc
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	// Arrays are rarely constant assigned, so for now we punt and do all entries
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	AstVarRef* varrefp = nodep->fromp()->castVarRef();
 	AstConst* constp = nodep->lsbp()->castConst();
 	if (varrefp && constp && !constp->num().isFourState()) {
@@ -310,7 +310,7 @@ private:
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	// Any variable
 	for (int usr=1; usr<(m_alwaysp?3:2); ++usr) {
 	    UndrivenVarEntry* entryp = getEntryp (nodep->varp(), usr);
@@ -327,14 +327,14 @@ private:
     }
 
     // Don't know what black boxed calls do, assume in+out
-    virtual void visit(AstSysIgnore* nodep, AstNUser*) {
+    virtual void visit(AstSysIgnore* nodep) {
 	bool prevMark = m_inBBox;
 	m_inBBox = true;
 	nodep->iterateChildren(*this);
 	m_inBBox = prevMark;
     }
 
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	AstAlways* prevAlwp = m_alwaysp;
 	{
 	    AstNode::user2ClearTree();
@@ -347,7 +347,7 @@ private:
 	m_alwaysp = prevAlwp;
     }
 
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	AstNodeFTask* prevTaskp = m_taskp;
 	m_taskp = nodep;
 	nodep->iterateChildren(*this);
@@ -355,18 +355,18 @@ private:
     }
 
     // Until we support tables, primitives will have undriven and unused I/Os
-    virtual void visit(AstPrimitive* nodep, AstNUser*) {}
+    virtual void visit(AstPrimitive* nodep) {}
 
     // Coverage artifacts etc shouldn't count as a sink
-    virtual void visit(AstCoverDecl* nodep, AstNUser*) {}
-    virtual void visit(AstCoverInc* nodep, AstNUser*) {}
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {}
-    virtual void visit(AstTraceDecl* nodep, AstNUser*) {}
-    virtual void visit(AstTraceInc* nodep, AstNUser*) {}
+    virtual void visit(AstCoverDecl* nodep) {}
+    virtual void visit(AstCoverInc* nodep) {}
+    virtual void visit(AstCoverToggle* nodep) {}
+    virtual void visit(AstTraceDecl* nodep) {}
+    virtual void visit(AstTraceInc* nodep) {}
 
     // iterate
-    virtual void visit(AstConst* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
diff --git a/src/V3Unknown.cpp b/src/V3Unknown.cpp
index 149e97558..99413e2bc 100644
--- a/src/V3Unknown.cpp
+++ b/src/V3Unknown.cpp
@@ -147,30 +147,30 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_constXCvt = true;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	m_assigndlyp = nodep;
 	nodep->iterateChildren(*this); VL_DANGLING(nodep);  // May delete nodep.
 	m_assigndlyp = NULL;
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	m_assignwp = nodep;
 	nodep->iterateChildren(*this); VL_DANGLING(nodep);  // May delete nodep.
 	m_assignwp = NULL;
     }
-    virtual void visit(AstCaseItem* nodep, AstNUser*) {
+    virtual void visit(AstCaseItem* nodep) {
 	m_constXCvt = false;  // Avoid losing the X's in casex
 	nodep->condsp()->iterateAndNext(*this);
 	m_constXCvt = true;
 	nodep->bodysp()->iterateAndNext(*this);
     }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeDType* nodep) {
 	m_constXCvt = false;  // Avoid losing the X's in casex
 	nodep->iterateChildren(*this);
 	m_constXCvt = true;
@@ -242,19 +242,19 @@ private:
 	}
     }
 
-    virtual void visit(AstEqCase* nodep, AstNUser*) {
+    virtual void visit(AstEqCase* nodep) {
 	visitEqNeqCase(nodep);
     }
-    virtual void visit(AstNeqCase* nodep, AstNUser*) {
+    virtual void visit(AstNeqCase* nodep) {
 	visitEqNeqCase(nodep);
     }
-    virtual void visit(AstEqWild* nodep, AstNUser*) {
+    virtual void visit(AstEqWild* nodep) {
 	visitEqNeqWild(nodep);
     }
-    virtual void visit(AstNeqWild* nodep, AstNUser*) {
+    virtual void visit(AstNeqWild* nodep) {
 	visitEqNeqWild(nodep);
     }
-    virtual void visit(AstIsUnknown* nodep, AstNUser*) {
+    virtual void visit(AstIsUnknown* nodep) {
 	nodep->iterateChildren(*this);
 	// Ahh, we're two state, so this is easy
 	UINFO(4," ISUNKNOWN->0 "<<nodep<<endl);
@@ -263,7 +263,7 @@ private:
 	nodep->replaceWith(newp);
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	if (m_constXCvt
 	    && nodep->num().isFourState()) {
 	    UINFO(4," CONST4 "<<nodep<<endl);
@@ -327,7 +327,7 @@ private:
 	}
     }
 
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->user1SetOnce()) {
 	    // Guard against reading/writing past end of bit vector array
@@ -375,7 +375,7 @@ private:
 	}
     }
 
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->user1SetOnce()) {
 	    if (debug()==9) nodep->dumpTree(cout,"-in: ");
@@ -453,7 +453,7 @@ private:
     }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
diff --git a/src/V3Unroll.cpp b/src/V3Unroll.cpp
index 083633362..91cfa96b3 100644
--- a/src/V3Unroll.cpp
+++ b/src/V3Unroll.cpp
@@ -358,7 +358,7 @@ private:
 	return true;
     }
 
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_varModeCheck || m_varModeReplace) {
 	} else {
@@ -387,7 +387,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstGenFor* nodep, AstNUser*) {
+    virtual void visit(AstGenFor* nodep) {
 	if (!m_generate || m_varModeReplace) {
 	    nodep->iterateChildren(*this);
 	}  // else V3Param will recursively call each for loop to be unrolled for us
@@ -415,7 +415,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeFor* nodep, AstNUser*) {
+    virtual void visit(AstNodeFor* nodep) {
 	if (m_generate) {  // Ignore for's when expanding genfor's
 	    nodep->iterateChildren(*this);
 	} else {
@@ -423,7 +423,7 @@ private:
 	}
     }
 
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (m_varModeCheck
 	    && nodep->varp() == m_forVarp
 	    && nodep->varScopep() == m_forVscp
@@ -444,7 +444,7 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	if (m_varModeCheck && nodep == m_ignoreIncp) {
 	    // Ignore subtree that is the increment
 	} else {
diff --git a/src/V3Width.cpp b/src/V3Width.cpp
index 716412623..695fa123d 100644
--- a/src/V3Width.cpp
+++ b/src/V3Width.cpp
@@ -215,128 +215,128 @@ private:
     //			_Ox=anything
 
     // Widths: 1 bit out, lhs 1 bit; Real: converts via compare with 0
-    virtual void visit(AstLogNot* nodep, AstNUser*) {	visit_log_not(nodep); }
+    virtual void visit(AstLogNot* nodep) {	visit_log_not(nodep); }
     // Widths: 1 bit out, lhs 1 bit, rhs 1 bit; Real: converts via compare with 0
-    virtual void visit(AstLogAnd* nodep, AstNUser*) {	visit_log_and_or(nodep); }
-    virtual void visit(AstLogOr* nodep, AstNUser*) {	visit_log_and_or(nodep); }
-    virtual void visit(AstLogIf* nodep, AstNUser*) {	visit_log_and_or(nodep); }  // Conversion from real not in IEEE, but a fallout
-    virtual void visit(AstLogIff* nodep, AstNUser*) {	visit_log_and_or(nodep); }  // Conversion from real not in IEEE, but a fallout
+    virtual void visit(AstLogAnd* nodep) {	visit_log_and_or(nodep); }
+    virtual void visit(AstLogOr* nodep) {	visit_log_and_or(nodep); }
+    virtual void visit(AstLogIf* nodep) {	visit_log_and_or(nodep); }  // Conversion from real not in IEEE, but a fallout
+    virtual void visit(AstLogIff* nodep) {	visit_log_and_or(nodep); }  // Conversion from real not in IEEE, but a fallout
 
     // Widths: 1 bit out, Any width lhs
-    virtual void visit(AstRedAnd* nodep, AstNUser*) {	visit_red_and_or(nodep); }
-    virtual void visit(AstRedOr* nodep, AstNUser*) {	visit_red_and_or(nodep); }
-    virtual void visit(AstRedXnor* nodep, AstNUser*){	visit_red_and_or(nodep); }
-    virtual void visit(AstRedXor* nodep, AstNUser*) {	visit_red_and_or(nodep); }
-    virtual void visit(AstOneHot* nodep, AstNUser*) {	visit_red_and_or(nodep); }
-    virtual void visit(AstOneHot0* nodep, AstNUser*) {	visit_red_and_or(nodep); }
-    virtual void visit(AstIsUnknown* nodep, AstNUser*) {	visit_red_unknown(nodep); }  // Allow real
+    virtual void visit(AstRedAnd* nodep) {	visit_red_and_or(nodep); }
+    virtual void visit(AstRedOr* nodep) {	visit_red_and_or(nodep); }
+    virtual void visit(AstRedXnor* nodep){	visit_red_and_or(nodep); }
+    virtual void visit(AstRedXor* nodep) {	visit_red_and_or(nodep); }
+    virtual void visit(AstOneHot* nodep) {	visit_red_and_or(nodep); }
+    virtual void visit(AstOneHot0* nodep) {	visit_red_and_or(nodep); }
+    virtual void visit(AstIsUnknown* nodep) {	visit_red_unknown(nodep); }  // Allow real
 
     // These have different node types, as they operate differently
     // Must add to case statement below,
     // Widths: 1 bit out, lhs width == rhs width.  real if lhs|rhs real
-    virtual void visit(AstEq* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstNeq* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGt* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGte* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLt* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLte* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGtS* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstGteS* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLtS* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstLteS* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstEqCase* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
-    virtual void visit(AstNeqCase* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstEq* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstNeq* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGt* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGte* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLt* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLte* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGtS* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstGteS* nodep) {	visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLtS* nodep) {		visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstLteS* nodep) {	visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstEqCase* nodep) {	visit_cmp_eq_gt(nodep, true); }
+    virtual void visit(AstNeqCase* nodep) {	visit_cmp_eq_gt(nodep, true); }
     // ...    These comparisons don't allow reals
-    virtual void visit(AstEqWild* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, false); }
-    virtual void visit(AstNeqWild* nodep, AstNUser*) {	visit_cmp_eq_gt(nodep, false); }
+    virtual void visit(AstEqWild* nodep) {	visit_cmp_eq_gt(nodep, false); }
+    virtual void visit(AstNeqWild* nodep) {	visit_cmp_eq_gt(nodep, false); }
     // ...    Real compares
-    virtual void visit(AstEqD* nodep, AstNUser*) {	visit_cmp_real(nodep); }
-    virtual void visit(AstNeqD* nodep, AstNUser*) {	visit_cmp_real(nodep); }
-    virtual void visit(AstLtD* nodep, AstNUser*) {	visit_cmp_real(nodep); }
-    virtual void visit(AstLteD* nodep, AstNUser*) {	visit_cmp_real(nodep); }
-    virtual void visit(AstGtD* nodep, AstNUser*) {	visit_cmp_real(nodep); }
-    virtual void visit(AstGteD* nodep, AstNUser*) {	visit_cmp_real(nodep); }
+    virtual void visit(AstEqD* nodep) {		visit_cmp_real(nodep); }
+    virtual void visit(AstNeqD* nodep) {	visit_cmp_real(nodep); }
+    virtual void visit(AstLtD* nodep) {		visit_cmp_real(nodep); }
+    virtual void visit(AstLteD* nodep) {	visit_cmp_real(nodep); }
+    virtual void visit(AstGtD* nodep) {		visit_cmp_real(nodep); }
+    virtual void visit(AstGteD* nodep) {	visit_cmp_real(nodep); }
     // ...    String compares
-    virtual void visit(AstEqN* nodep, AstNUser*) {	visit_cmp_string(nodep); }
-    virtual void visit(AstNeqN* nodep, AstNUser*) {	visit_cmp_string(nodep); }
-    virtual void visit(AstLtN* nodep, AstNUser*) {	visit_cmp_string(nodep); }
-    virtual void visit(AstLteN* nodep, AstNUser*) {	visit_cmp_string(nodep); }
-    virtual void visit(AstGtN* nodep, AstNUser*) {	visit_cmp_string(nodep); }
-    virtual void visit(AstGteN* nodep, AstNUser*) {	visit_cmp_string(nodep); }
+    virtual void visit(AstEqN* nodep) {		visit_cmp_string(nodep); }
+    virtual void visit(AstNeqN* nodep) {	visit_cmp_string(nodep); }
+    virtual void visit(AstLtN* nodep) {		visit_cmp_string(nodep); }
+    virtual void visit(AstLteN* nodep) {	visit_cmp_string(nodep); }
+    virtual void visit(AstGtN* nodep) {		visit_cmp_string(nodep); }
+    virtual void visit(AstGteN* nodep) {	visit_cmp_string(nodep); }
 
     // Widths: out width = lhs width = rhs width
     // Signed: Output signed iff LHS & RHS signed.
     // Real: Not allowed
-    virtual void visit(AstAnd* nodep, AstNUser*) {	visit_boolmath_and_or(nodep); }
-    virtual void visit(AstOr* nodep, AstNUser*) {	visit_boolmath_and_or(nodep); }
-    virtual void visit(AstXnor* nodep, AstNUser*) {	visit_boolmath_and_or(nodep); }
-    virtual void visit(AstXor* nodep, AstNUser*) {	visit_boolmath_and_or(nodep); }
-    virtual void visit(AstBufIf1* nodep, AstNUser*) {	visit_boolmath_and_or(nodep); }  // Signed behavior changing in 3.814
+    virtual void visit(AstAnd* nodep) {		visit_boolmath_and_or(nodep); }
+    virtual void visit(AstOr* nodep) {		visit_boolmath_and_or(nodep); }
+    virtual void visit(AstXnor* nodep) {	visit_boolmath_and_or(nodep); }
+    virtual void visit(AstXor* nodep) {		visit_boolmath_and_or(nodep); }
+    virtual void visit(AstBufIf1* nodep) {	visit_boolmath_and_or(nodep); }  // Signed behavior changing in 3.814
     // Width: Max(Lhs,Rhs) sort of.
     // Real: If either side real
     // Signed: If both sides real
-    virtual void visit(AstAdd* nodep, AstNUser*) {	visit_add_sub_replace(nodep, true); }
-    virtual void visit(AstSub* nodep, AstNUser*) {	visit_add_sub_replace(nodep, true); }
-    virtual void visit(AstDiv* nodep, AstNUser*) {	visit_add_sub_replace(nodep, true); }
-    virtual void visit(AstMul* nodep, AstNUser*) {	visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstAdd* nodep) {		visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstSub* nodep) {		visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstDiv* nodep) {		visit_add_sub_replace(nodep, true); }
+    virtual void visit(AstMul* nodep) {		visit_add_sub_replace(nodep, true); }
     // These can't promote to real
-    virtual void visit(AstModDiv* nodep, AstNUser*) {	visit_add_sub_replace(nodep, false); }
-    virtual void visit(AstModDivS* nodep, AstNUser*) {	visit_add_sub_replace(nodep, false); }
-    virtual void visit(AstMulS* nodep, AstNUser*) {	visit_add_sub_replace(nodep, false); }
-    virtual void visit(AstDivS* nodep, AstNUser*) {	visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstModDiv* nodep) {	visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstModDivS* nodep) {	visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstMulS* nodep) {	visit_add_sub_replace(nodep, false); }
+    virtual void visit(AstDivS* nodep) {	visit_add_sub_replace(nodep, false); }
     // Widths: out width = lhs width, but upper matters
     // Signed: Output signed iff LHS signed; unary operator
     // Unary promote to real
-    virtual void visit(AstNegate* nodep, AstNUser*) {	visit_negate_not(nodep, true); }
+    virtual void visit(AstNegate* nodep) {	visit_negate_not(nodep, true); }
     // Unary never real
-    virtual void visit(AstNot* nodep, AstNUser*) {	visit_negate_not(nodep, false); }
+    virtual void visit(AstNot* nodep) {		visit_negate_not(nodep, false); }
 
     // Real: inputs and output real
-    virtual void visit(AstAddD* nodep, AstNUser*) {	visit_real_add_sub(nodep); }
-    virtual void visit(AstSubD* nodep, AstNUser*) {	visit_real_add_sub(nodep); }
-    virtual void visit(AstDivD* nodep, AstNUser*) {	visit_real_add_sub(nodep); }
-    virtual void visit(AstMulD* nodep, AstNUser*) {	visit_real_add_sub(nodep); }
-    virtual void visit(AstPowD* nodep, AstNUser*) {	visit_real_add_sub(nodep); }
+    virtual void visit(AstAddD* nodep) {	visit_real_add_sub(nodep); }
+    virtual void visit(AstSubD* nodep) {	visit_real_add_sub(nodep); }
+    virtual void visit(AstDivD* nodep) {	visit_real_add_sub(nodep); }
+    virtual void visit(AstMulD* nodep) {	visit_real_add_sub(nodep); }
+    virtual void visit(AstPowD* nodep) {	visit_real_add_sub(nodep); }
     // Real: Output real
-    virtual void visit(AstNegateD* nodep, AstNUser*) {	visit_real_neg_ceil(nodep); }
-    virtual void visit(AstCeilD* nodep, AstNUser*) {	visit_real_neg_ceil(nodep); }
-    virtual void visit(AstExpD* nodep, AstNUser*) {	visit_real_neg_ceil(nodep); }
-    virtual void visit(AstFloorD* nodep, AstNUser*) {	visit_real_neg_ceil(nodep); }
-    virtual void visit(AstLogD* nodep, AstNUser*) {	visit_real_neg_ceil(nodep); }
-    virtual void visit(AstLog10D* nodep, AstNUser*) {	visit_real_neg_ceil(nodep); }
-    virtual void visit(AstSqrtD* nodep, AstNUser*) {	visit_real_neg_ceil(nodep); }
+    virtual void visit(AstNegateD* nodep) {	visit_real_neg_ceil(nodep); }
+    virtual void visit(AstCeilD* nodep) {	visit_real_neg_ceil(nodep); }
+    virtual void visit(AstExpD* nodep) {	visit_real_neg_ceil(nodep); }
+    virtual void visit(AstFloorD* nodep) {	visit_real_neg_ceil(nodep); }
+    virtual void visit(AstLogD* nodep) {	visit_real_neg_ceil(nodep); }
+    virtual void visit(AstLog10D* nodep) {	visit_real_neg_ceil(nodep); }
+    virtual void visit(AstSqrtD* nodep) {	visit_real_neg_ceil(nodep); }
 
     // Widths: out signed/unsigned width = lhs width, input un|signed
-    virtual void visit(AstSigned* nodep, AstNUser*) {	visit_signed_unsigned(nodep, AstNumeric::SIGNED); }
-    virtual void visit(AstUnsigned* nodep, AstNUser*) {	visit_signed_unsigned(nodep, AstNumeric::UNSIGNED); }
+    virtual void visit(AstSigned* nodep) {	visit_signed_unsigned(nodep, AstNumeric::SIGNED); }
+    virtual void visit(AstUnsigned* nodep) {	visit_signed_unsigned(nodep, AstNumeric::UNSIGNED); }
 
     // Widths: Output width from lhs, rhs<33 bits
     // Signed: If lhs signed
-    virtual void visit(AstShiftL* nodep, AstNUser*) {	visit_shift(nodep); }
-    virtual void visit(AstShiftR* nodep, AstNUser*) {	visit_shift(nodep); }
+    virtual void visit(AstShiftL* nodep) {	visit_shift(nodep); }
+    virtual void visit(AstShiftR* nodep) {	visit_shift(nodep); }
     // ShiftRS converts to ShiftR, but not vice-versa
-    virtual void visit(AstShiftRS* nodep, AstNUser*) {	visit_shift(nodep); }
+    virtual void visit(AstShiftRS* nodep) {	visit_shift(nodep); }
 
     //========
     // Widths: Output real, input integer signed
-    virtual void visit(AstBitsToRealD* nodep, AstNUser*) {	visit_Or_Lu64(nodep); }
-    virtual void visit(AstIToRD* nodep, AstNUser*) {		visit_Or_Ls32(nodep); }
+    virtual void visit(AstBitsToRealD* nodep) {	visit_Or_Lu64(nodep); }
+    virtual void visit(AstIToRD* nodep) {	visit_Or_Ls32(nodep); }
 
     // Widths: Output integer signed, input real
-    virtual void visit(AstRToIS* nodep, AstNUser*) {		visit_Os32_Lr(nodep); }
-    virtual void visit(AstRToIRoundS* nodep, AstNUser*) {	visit_Os32_Lr(nodep); }
+    virtual void visit(AstRToIS* nodep) {	visit_Os32_Lr(nodep); }
+    virtual void visit(AstRToIRoundS* nodep) {	visit_Os32_Lr(nodep); }
 
     // Widths: Output integer unsigned, input real
-    virtual void visit(AstRealToBits* nodep, AstNUser*) {	visit_Ou64_Lr(nodep); }
+    virtual void visit(AstRealToBits* nodep) {	visit_Ou64_Lr(nodep); }
 
     // Widths: Constant, terminal
-    virtual void visit(AstTime* nodep, AstNUser*) {		nodep->dtypeSetUInt64(); }
-    virtual void visit(AstTimeD* nodep, AstNUser*) {		nodep->dtypeSetDouble(); }
-    virtual void visit(AstTestPlusArgs* nodep, AstNUser*) {	nodep->dtypeSetSigned32(); }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {	nodep->dtypeSetUInt64(); }	// A pointer, but not that it matters
+    virtual void visit(AstTime* nodep) {	nodep->dtypeSetUInt64(); }
+    virtual void visit(AstTimeD* nodep) {	nodep->dtypeSetDouble(); }
+    virtual void visit(AstTestPlusArgs* nodep) { nodep->dtypeSetSigned32(); }
+    virtual void visit(AstScopeName* nodep) {	nodep->dtypeSetUInt64(); }	// A pointer, but not that it matters
 
     // Special cases.  So many....
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	// op=cond?expr1:expr2
 	// Signed: Output signed iff RHS & THS signed  (presumed, not in IEEE)
 	// See IEEE-2012 11.4.11 and Table 11-21.
@@ -373,7 +373,7 @@ private:
 	    iterateCheck(nodep,"Conditional False",nodep->expr2p(),CONTEXT,FINAL,subDTypep,EXTEND_EXP);
 	}
     }
-    virtual void visit(AstConcat* nodep, AstNUser*) {
+    virtual void visit(AstConcat* nodep) {
 	// Real: Not allowed (assumed)
 	// Signed: unsigned output, input either (assumed)
 	// IEEE-2012 Table 11-21, and 11.8.1:
@@ -418,7 +418,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstConcatN* nodep, AstNUser*) {
+    virtual void visit(AstConcatN* nodep) {
 	// String concatenate.
 	// Already did AstConcat simplifications
 	if (m_vup->prelim()) {
@@ -433,7 +433,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstReplicate* nodep, AstNUser*) {
+    virtual void visit(AstReplicate* nodep) {
 	// IEEE-2012 Table 11-21:
 	//   LHS, RHS is self-determined
 	//   width: value(LHS) * width(RHS)
@@ -466,7 +466,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstReplicateN* nodep, AstNUser*) {
+    virtual void visit(AstReplicateN* nodep) {
 	// Replicate with string
 	if (m_vup->prelim()) {
 	    iterateCheckString(nodep,"LHS",nodep->lhsp(),BOTH);
@@ -487,7 +487,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeStream* nodep, AstNUser*) {
+    virtual void visit(AstNodeStream* nodep) {
 	if (m_vup->prelim()) {
 	    iterateCheckSizedSelf(nodep,"LHS",nodep->lhsp(),SELF,BOTH);
 	    iterateCheckSizedSelf(nodep,"RHS",nodep->rhsp(),SELF,BOTH);
@@ -514,7 +514,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstRange* nodep, AstNUser*) {
+    virtual void visit(AstRange* nodep) {
 	// Real: Not allowed
 	// Signed: unsigned output, input either
 	// Convert all range values to constants
@@ -545,7 +545,7 @@ private:
 	}
     }
 
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	// Signed: always unsigned; Real: Not allowed
 	// LSB is self-determined (IEEE 2012 11.5.1)
 	// We also use SELs to shorten a signed constant etc, in this case they are signed.
@@ -643,7 +643,7 @@ private:
 	}
     }
 
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	// Signed/Real: Output signed iff LHS signed/real; binary operator
 	// Note by contrast, bit extract selects are unsigned
 	// LSB is self-determined (IEEE 2012 11.5.1)
@@ -698,7 +698,7 @@ private:
 	}
     }
 
-    virtual void visit(AstSelBit* nodep, AstNUser*) {
+    virtual void visit(AstSelBit* nodep) {
 	// Just a quick check as after V3Param these nodes instead are AstSel's
 	userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
 	userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
@@ -707,7 +707,7 @@ private:
 	AstNode* selp = V3Width::widthSelNoIterEdit(nodep); if (selp!=nodep) { nodep=NULL; userIterate(selp, m_vup); return; }
 	nodep->v3fatalSrc("AstSelBit should disappear after widthSel");
     }
-    virtual void visit(AstSelExtract* nodep, AstNUser*) {
+    virtual void visit(AstSelExtract* nodep) {
 	// Just a quick check as after V3Param these nodes instead are AstSel's
 	userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
 	userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
@@ -716,7 +716,7 @@ private:
 	AstNode* selp = V3Width::widthSelNoIterEdit(nodep); if (selp!=nodep) { nodep=NULL; userIterate(selp, m_vup); return; }
 	nodep->v3fatalSrc("AstSelExtract should disappear after widthSel");
     }
-    virtual void visit(AstSelPlus* nodep, AstNUser*) {
+    virtual void visit(AstSelPlus* nodep) {
 	userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
 	userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
 	userIterateAndNext(nodep->thsp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
@@ -724,7 +724,7 @@ private:
 	AstNode* selp = V3Width::widthSelNoIterEdit(nodep); if (selp!=nodep) { nodep=NULL; userIterate(selp, m_vup); return; }
 	nodep->v3fatalSrc("AstSelPlus should disappear after widthSel");
     }
-    virtual void visit(AstSelMinus* nodep, AstNUser*) {
+    virtual void visit(AstSelMinus* nodep) {
 	userIterateAndNext(nodep->fromp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
 	userIterateAndNext(nodep->rhsp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
 	userIterateAndNext(nodep->thsp(), WidthVP(CONTEXT,PRELIM).p()); //FINAL in AstSel
@@ -733,13 +733,13 @@ private:
 	nodep->v3fatalSrc("AstSelMinus should disappear after widthSel");
     }
 
-    virtual void visit(AstExtend* nodep, AstNUser*) {
+    virtual void visit(AstExtend* nodep) {
 	// Only created by this process, so we know width from here down is correct.
     }
-    virtual void visit(AstExtendS* nodep, AstNUser*) {
+    virtual void visit(AstExtendS* nodep) {
 	// Only created by this process, so we know width from here down is correct.
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	// The node got setup with the signed/real state of the node.
 	// However a later operation may have changed the node->signed w/o changing
 	// the number's sign.  So we don't: nodep->dtypeChgSigned(nodep->num().isSigned());
@@ -755,12 +755,12 @@ private:
 	// We don't size the constant until we commit the widths, as need parameters
 	// to remain unsized, and numbers to remain unsized to avoid backp() warnings
     }
-    virtual void visit(AstRand* nodep, AstNUser*) {
+    virtual void visit(AstRand* nodep) {
 	if (m_vup->prelim()) {
 	    nodep->dtypeSetSigned32();  // Says the spec
 	}
     }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	// Give it the size the user wants.
 	if (m_vup && m_vup->prelim()) {
 	    nodep->dtypeSetLogicSized(32,1,AstNumeric::UNSIGNED);  // We don't care
@@ -773,13 +773,13 @@ private:
 	    if (nodep->width()>64) nodep->v3error("Unsupported: $c can't generate wider than 64 bits");
 	}
     }
-    virtual void visit(AstCLog2* nodep, AstNUser*) {
+    virtual void visit(AstCLog2* nodep) {
 	if (m_vup->prelim()) {
 	    iterateCheckSizedSelf(nodep,"LHS",nodep->lhsp(),SELF,BOTH);
 	    nodep->dtypeSetSigned32();
 	}
     }
-    virtual void visit(AstPow* nodep, AstNUser*) {
+    virtual void visit(AstPow* nodep) {
 	// Pow is special, output sign only depends on LHS sign, but function result depends on both signs
 	// RHS is self-determined (IEEE)
 	// Real if either side is real (as with AstAdd)
@@ -823,22 +823,22 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstPowSU* nodep, AstNUser*) {
+    virtual void visit(AstPowSU* nodep) {
 	// POWSU/SS/US only created here, dtype already determined, so nothing to do in this function
 	userIterateAndNext(nodep->lhsp(), WidthVP(SELF,BOTH).p());
 	userIterateAndNext(nodep->rhsp(), WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstPowSS* nodep, AstNUser*) {
+    virtual void visit(AstPowSS* nodep) {
 	// POWSU/SS/US only created here, dtype already determined, so nothing to do in this function
 	userIterateAndNext(nodep->lhsp(), WidthVP(SELF,BOTH).p());
 	userIterateAndNext(nodep->rhsp(), WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstPowUS* nodep, AstNUser*) {
+    virtual void visit(AstPowUS* nodep) {
 	// POWSU/SS/US only created here, dtype already determined, so nothing to do in this function
 	userIterateAndNext(nodep->lhsp(), WidthVP(SELF,BOTH).p());
 	userIterateAndNext(nodep->rhsp(), WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstCountOnes* nodep, AstNUser*) {
+    virtual void visit(AstCountOnes* nodep) {
 	if (m_vup->prelim()) {
 	    iterateCheckSizedSelf(nodep,"LHS",nodep->lhsp(),SELF,BOTH);
 	    // If it's a 32 bit number, we need a 6 bit number as we need to return '32'.
@@ -846,12 +846,12 @@ private:
 	    nodep->dtypeSetLogicSized(selwidth,selwidth,AstNumeric::UNSIGNED);  // Spec doesn't indicate if an integer
 	}
     }
-    virtual void visit(AstCvtPackString* nodep, AstNUser*) {
+    virtual void visit(AstCvtPackString* nodep) {
 	// Opaque returns, so arbitrary
 	userIterateAndNext(nodep->lhsp(), WidthVP(SELF,BOTH).p());
 	// Type set in constructor
     }
-    virtual void visit(AstAttrOf* nodep, AstNUser*) {
+    virtual void visit(AstAttrOf* nodep) {
 	AstAttrOf* oldAttr = m_attrp;
 	m_attrp = nodep;
 	userIterateAndNext(nodep->fromp(), WidthVP(SELF,BOTH).p());
@@ -907,12 +907,12 @@ private:
 	}
 	m_attrp = oldAttr;
     }
-    virtual void visit(AstText* nodep, AstNUser*) {
+    virtual void visit(AstText* nodep) {
 	// Only used in CStmts which don't care....
     }
 
     // DTYPES
-    virtual void visit(AstNodeArrayDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeArrayDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	if (nodep->childDTypep()) nodep->refDTypep(moveChildDTypeEdit(nodep));
 	// Iterate into subDTypep() to resolve that type and update pointer.
@@ -929,7 +929,7 @@ private:
 	}
 	UINFO(4,"dtWidthed "<<nodep<<endl);
     }
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	if (nodep->generic()) return;  // Already perfect
 	if (nodep->rangep()) {
@@ -953,7 +953,7 @@ private:
 	// Instead for now doing this in V3WidthCommit
 	UINFO(4,"dtWidthed "<<nodep<<endl);
     }
-    virtual void visit(AstConstDType* nodep, AstNUser*) {
+    virtual void visit(AstConstDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	// Move any childDTypep to instead be in global AstTypeTable.
 	// This way if this node gets deleted and some other dtype points to it
@@ -966,7 +966,7 @@ private:
 	nodep->widthFromSub(nodep->subDTypep());
 	UINFO(4,"dtWidthed "<<nodep<<endl);
     }
-    virtual void visit(AstRefDType* nodep, AstNUser*) {
+    virtual void visit(AstRefDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	userIterateChildren(nodep, NULL);
 	if (nodep->subDTypep()) nodep->refDTypep(iterateEditDTypep(nodep, nodep->subDTypep()));
@@ -974,20 +974,20 @@ private:
 	nodep->widthFromSub(nodep->subDTypep());
 	UINFO(4,"dtWidthed "<<nodep<<endl);
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstTypedef* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	if (nodep->childDTypep()) nodep->dtypep(moveChildDTypeEdit(nodep));
 	userIterateChildren(nodep, NULL);
 	nodep->dtypep(iterateEditDTypep(nodep, nodep->subDTypep()));
     }
-    virtual void visit(AstParamTypeDType* nodep, AstNUser*) {
+    virtual void visit(AstParamTypeDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	if (nodep->childDTypep()) nodep->dtypep(moveChildDTypeEdit(nodep));
 	userIterateChildren(nodep, NULL);
 	nodep->dtypep(iterateEditDTypep(nodep, nodep->subDTypep()));
 	nodep->widthFromSub(nodep->subDTypep());
     }
-    virtual void visit(AstCastParse* nodep, AstNUser*) {
+    virtual void visit(AstCastParse* nodep) {
 	// nodep->dtp could be data type, or a primary_constant
 	// Don't iterate lhsp, will deal with that once convert the type
 	V3Const::constifyParamsEdit(nodep->dtp()); // itemp may change
@@ -1002,7 +1002,7 @@ private:
 	    nodep->replaceWith(nodep->lhsp()->unlinkFrBack());
 	}
     }
-    virtual void visit(AstCast* nodep, AstNUser*) {
+    virtual void visit(AstCast* nodep) {
 	if (nodep->childDTypep()) nodep->dtypep(moveChildDTypeEdit(nodep));
 	nodep->dtypep(iterateEditDTypep(nodep, nodep->dtypep()));
 	//if (debug()) nodep->dumpTree(cout,"  CastPre: ");
@@ -1041,7 +1041,7 @@ private:
 	pushDeletep(nodep); VL_DANGLING(nodep);
 	//if (debug()) newp->dumpTree(cout,"  CastOut: ");
     }
-    virtual void visit(AstCastSize* nodep, AstNUser*) {
+    virtual void visit(AstCastSize* nodep) {
 	// IEEE: Signedness of result is same as self-determined signedness
 	// However, the result is same as BITSEL, so we do not sign extend the LHS
 	if (!nodep->rhsp()->castConst()) nodep->v3fatalSrc("Unsupported: Non-const cast of size");
@@ -1090,7 +1090,7 @@ private:
 	}
 	//if (debug()) nodep->dumpTree(cout,"  CastSizeOut: ");
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	//if (debug()) nodep->dumpTree(cout,"  InitPre: ");
 	// Must have deterministic constant width
 	// We can't skip this step when width()!=0, as creating a AstVar
@@ -1182,7 +1182,7 @@ private:
 	nodep->didWidth(true);
 	nodep->doingWidth(false);
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	if (nodep->didWidth()) return;
 	if (!nodep->varp()) nodep->v3fatalSrc("Unlinked varref");
 	if (!nodep->varp()->didWidth()) {
@@ -1205,7 +1205,7 @@ private:
 	nodep->didWidth(true);
     }
 
-    virtual void visit(AstEnumDType* nodep, AstNUser*) {
+    virtual void visit(AstEnumDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	UINFO(5,"  ENUMDTYPE "<<nodep<<endl);
 	if (nodep->childDTypep()) nodep->refDTypep(moveChildDTypeEdit(nodep));
@@ -1251,7 +1251,7 @@ private:
 	    num.opAdd(one, itemp->valuep()->castConst()->num());
 	}
     }
-    virtual void visit(AstEnumItem* nodep, AstNUser*) {
+    virtual void visit(AstEnumItem* nodep) {
 	UINFO(5,"   ENUMITEM "<<nodep<<endl);
 	AstNodeDType* vdtypep = m_vup->dtypep();
 	if (!vdtypep) nodep->v3fatalSrc("ENUMITEM not under ENUM");
@@ -1264,7 +1264,7 @@ private:
 	    iterateCheck(nodep,"Enum value",nodep->valuep(),CONTEXT,FINAL,nodep->dtypep(),EXTEND_EXP);
 	}
     }
-    virtual void visit(AstEnumItemRef* nodep, AstNUser*) {
+    virtual void visit(AstEnumItemRef* nodep) {
 	if (!nodep->itemp()->didWidth()) {
 	    // We need to do the whole enum en-mass
 	    AstNode* enump = nodep->itemp();
@@ -1277,7 +1277,7 @@ private:
 	}
 	nodep->dtypeFrom(nodep->itemp());
     }
-    virtual void visit(AstInitArray* nodep, AstNUser*) {
+    virtual void visit(AstInitArray* nodep) {
 	// InitArray has type of the array; children are array values
 	if (m_vup->prelim()) {  // First stage evaluation
 	    AstNodeDType* vdtypep = m_vup->dtypep();
@@ -1290,7 +1290,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstInside* nodep, AstNUser*) {
+    virtual void visit(AstInside* nodep) {
 	userIterateAndNext(nodep->exprp(), WidthVP(CONTEXT,PRELIM).p());
 	for (AstNode* nextip, *itemp = nodep->itemsp(); itemp; itemp=nextip) {
 	    nextip = itemp->nextp(); // Prelim may cause the node to get replaced
@@ -1337,14 +1337,14 @@ private:
 	if (debug()>=9) newp->dumpTree(cout,"-inside-out: ");
 	nodep->replaceWith(newp); pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstInsideRange* nodep, AstNUser*) {
+    virtual void visit(AstInsideRange* nodep) {
 	// Just do each side; AstInside will rip these nodes out later
 	userIterateAndNext(nodep->lhsp(), m_vup);
 	userIterateAndNext(nodep->rhsp(), m_vup);
 	nodep->dtypeFrom(nodep->lhsp());
     }
 
-    virtual void visit(AstIfaceRefDType* nodep, AstNUser*) {
+    virtual void visit(AstIfaceRefDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	UINFO(5,"   IFACEREF "<<nodep<<endl);
 	userIterateChildren(nodep, m_vup);
@@ -1352,7 +1352,7 @@ private:
 	nodep->widthForce(1, 1); // Not really relevant
 	UINFO(4,"dtWidthed "<<nodep<<endl);
     }
-    virtual void visit(AstNodeClassDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeClassDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	UINFO(5,"   NODECLASS "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree("-class-in--");
@@ -1381,7 +1381,7 @@ private:
 	nodep->widthForce(width,width);  // Signing stays as-is, as parsed from declaration
 	//if (debug()>=9) nodep->dumpTree("-class-out-");
     }
-    virtual void visit(AstMemberDType* nodep, AstNUser*) {
+    virtual void visit(AstMemberDType* nodep) {
 	if (nodep->didWidthAndSet()) return;  // This node is a dtype & not both PRELIMed+FINALed
 	if (nodep->childDTypep()) nodep->refDTypep(moveChildDTypeEdit(nodep));
 	// Iterate into subDTypep() to resolve that type and update pointer.
@@ -1389,7 +1389,7 @@ private:
 	nodep->dtypep(nodep);  // The member itself, not subDtype
 	nodep->widthFromSub(nodep->subDTypep());
     }
-    virtual void visit(AstMemberSel* nodep, AstNUser*) {
+    virtual void visit(AstMemberSel* nodep) {
 	UINFO(5,"   MEMBERSEL "<<nodep<<endl);
 	if (debug()>=9) nodep->dumpTree("-mbs-in: ");
 	userIterateChildren(nodep, WidthVP(SELF,BOTH).p());
@@ -1441,7 +1441,7 @@ private:
 	}
     }
 
-    virtual void visit(AstMethodSel* nodep, AstNUser*) {
+    virtual void visit(AstMethodSel* nodep) {
 	UINFO(5,"   METHODSEL "<<nodep<<endl);
 	if (debug()>=9) nodep->dumpTree("-mts-in: ");
 	// Should check types the method requires, but at present we don't do much
@@ -1535,7 +1535,7 @@ private:
 	}
     }
 
-    virtual void visit(AstPattern* nodep, AstNUser*) {
+    virtual void visit(AstPattern* nodep) {
 	if (nodep->didWidthAndSet()) return;
 	UINFO(9,"PATTERN "<<nodep<<endl);
 	if (nodep->childDTypep()) nodep->dtypep(moveChildDTypeEdit(nodep));  // data_type '{ pattern }
@@ -1798,7 +1798,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstPatMember* nodep, AstNUser*) {
+    virtual void visit(AstPatMember* nodep) {
 	AstNodeDType* vdtypep = m_vup->dtypeNullp();
 	if (!vdtypep) nodep->v3fatalSrc("Pattern member type not assigned by AstPattern visitor");
 	nodep->dtypep(vdtypep);
@@ -1822,7 +1822,7 @@ private:
 	return times;
     }
 
-    virtual void visit(AstPslClocked* nodep, AstNUser*) {
+    virtual void visit(AstPslClocked* nodep) {
 	if (m_vup->prelim()) {  // First stage evaluation
 	    iterateCheckBool(nodep,"Property",nodep->propp(),BOTH);
 	    userIterateAndNext(nodep->sensesp(), NULL);
@@ -1836,7 +1836,7 @@ private:
     //--------------------
     // Top levels
 
-    virtual void visit(AstNodeCase* nodep, AstNUser*) {
+    virtual void visit(AstNodeCase* nodep) {
 	// IEEE-2012 12.5:
 	//    Width: MAX(expr, all items)
 	//    Signed: Only if expr, and all items signed
@@ -1876,7 +1876,7 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNodeFor* nodep, AstNUser*) {
+    virtual void visit(AstNodeFor* nodep) {
 	assertAtStatement(nodep);
 	userIterateAndNext(nodep->initsp(), NULL);
 	iterateCheckBool(nodep,"For Test Condition",nodep->condp(),BOTH);	// it's like an if() condition.
@@ -1884,19 +1884,19 @@ private:
 	userIterateAndNext(nodep->incsp(), NULL);
 
     }
-    virtual void visit(AstRepeat* nodep, AstNUser*) {
+    virtual void visit(AstRepeat* nodep) {
 	assertAtStatement(nodep);
 	userIterateAndNext(nodep->countp(), WidthVP(SELF,BOTH).p());
 	userIterateAndNext(nodep->bodysp(), NULL);
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	assertAtStatement(nodep);
 	userIterateAndNext(nodep->precondsp(), NULL);
 	iterateCheckBool(nodep,"For Test Condition",nodep->condp(),BOTH);	// it's like an if() condition.
 	userIterateAndNext(nodep->bodysp(), NULL);
 	userIterateAndNext(nodep->incsp(), NULL);
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	assertAtStatement(nodep);
 	//if (debug()) nodep->dumpTree(cout,"  IfPre: ");
 	if (!nodep->castGenIf()) {  // for m_paramsOnly
@@ -1907,7 +1907,7 @@ private:
 	//if (debug()) nodep->dumpTree(cout,"  IfOut: ");
     }
 
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	// IEEE-2012 10.7, 11.8.2, 11.8.3, 11.5:  (Careful of 11.8.1 which is
 	//                  only one step; final dtype depends on assign LHS.)
 	//    Determine RHS type width and signing
@@ -1933,7 +1933,7 @@ private:
 	}
     }
 
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	// Excludes NodeDisplay, see below
 	if (m_vup && !m_vup->prelim()) return;  // Can be called as statement or function
 	// Just let all arguments seek their natural sizes
@@ -2001,7 +2001,7 @@ private:
 	nodep->text(newFormat);
 	UINFO(9,"  Display out "<<nodep->text()<<endl);
     }
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstDisplay* nodep) {
 	assertAtStatement(nodep);
 	if (nodep->filep()) {
 	    iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
@@ -2009,70 +2009,70 @@ private:
 	// Just let all arguments seek their natural sizes
 	userIterateChildren(nodep, WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstFOpen* nodep, AstNUser*) {
+    virtual void visit(AstFOpen* nodep) {
 	// Although a system function in IEEE, here a statement which sets the file pointer (MCD)
 	assertAtStatement(nodep);
 	iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
 	userIterateAndNext(nodep->filenamep(), WidthVP(SELF,BOTH).p());
 	userIterateAndNext(nodep->modep(), WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstFClose* nodep, AstNUser*) {
+    virtual void visit(AstFClose* nodep) {
 	assertAtStatement(nodep);
 	iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
     }
-    virtual void visit(AstFEof* nodep, AstNUser*) {
+    virtual void visit(AstFEof* nodep) {
 	if (m_vup->prelim()) {
 	    iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
 	    nodep->dtypeSetLogicSized(32,1,AstNumeric::SIGNED);  // Spec says integer return
 	}
     }
-    virtual void visit(AstFFlush* nodep, AstNUser*) {
+    virtual void visit(AstFFlush* nodep) {
 	assertAtStatement(nodep);
 	if (nodep->filep()) {
 	    iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
 	}
     }
-    virtual void visit(AstFGetC* nodep, AstNUser*) {
+    virtual void visit(AstFGetC* nodep) {
 	if (m_vup->prelim()) {
 	    iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
 	    nodep->dtypeSetLogicSized(32,8,AstNumeric::SIGNED);  // Spec says integer return
 	}
     }
-    virtual void visit(AstFGetS* nodep, AstNUser*) {
+    virtual void visit(AstFGetS* nodep) {
 	if (m_vup->prelim()) {
 	    nodep->dtypeSetSigned32();  // Spec says integer return
 	    iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
 	    userIterateAndNext(nodep->strgp(), WidthVP(SELF,BOTH).p());
 	}
     }
-    virtual void visit(AstFScanF* nodep, AstNUser*) {
+    virtual void visit(AstFScanF* nodep) {
 	if (m_vup->prelim()) {
 	    nodep->dtypeSetSigned32();  // Spec says integer return
 	    iterateCheckFileDesc(nodep,nodep->filep(),BOTH);
 	    userIterateAndNext(nodep->exprsp(), WidthVP(SELF,BOTH).p());
 	}
     }
-    virtual void visit(AstSScanF* nodep, AstNUser*) {
+    virtual void visit(AstSScanF* nodep) {
 	if (m_vup->prelim()) {
 	    nodep->dtypeSetSigned32();  // Spec says integer return
 	    userIterateAndNext(nodep->fromp(), WidthVP(SELF,BOTH).p());
 	    userIterateAndNext(nodep->exprsp(), WidthVP(SELF,BOTH).p());
 	}
     }
-    virtual void visit(AstSysIgnore* nodep, AstNUser*) {
+    virtual void visit(AstSysIgnore* nodep) {
 	userIterateAndNext(nodep->exprsp(), WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstSystemF* nodep, AstNUser*) {
+    virtual void visit(AstSystemF* nodep) {
 	if (m_vup->prelim()) {
 	    userIterateAndNext(nodep->lhsp(), WidthVP(SELF,BOTH).p());
 	    nodep->dtypeSetSigned32();  // Spec says integer return
 	}
     }
-    virtual void visit(AstSystemT* nodep, AstNUser*) {
+    virtual void visit(AstSystemT* nodep) {
 	assertAtStatement(nodep);
 	userIterateAndNext(nodep->lhsp(), WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstReadMem* nodep, AstNUser*) {
+    virtual void visit(AstReadMem* nodep) {
 	assertAtStatement(nodep);
 	userIterateAndNext(nodep->filenamep(), WidthVP(SELF,BOTH).p());
 	userIterateAndNext(nodep->memp(), WidthVP(SELF,BOTH).p());
@@ -2082,29 +2082,29 @@ private:
 	userIterateAndNext(nodep->lsbp(), WidthVP(SELF,BOTH).p());
 	userIterateAndNext(nodep->msbp(), WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstValuePlusArgs* nodep, AstNUser*) {
+    virtual void visit(AstValuePlusArgs* nodep) {
 	if (m_vup->prelim()) {
 	    userIterateAndNext(nodep->exprsp(), WidthVP(SELF,BOTH).p());
 	    nodep->dtypeSetSigned32();  // Spec says integer return
 	}
     }
-    virtual void visit(AstUCStmt* nodep, AstNUser*) {
+    virtual void visit(AstUCStmt* nodep) {
 	// Just let all arguments seek their natural sizes
 	assertAtStatement(nodep);
 	userIterateChildren(nodep, WidthVP(SELF,BOTH).p());
     }
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    virtual void visit(AstPslCover* nodep) {
 	assertAtStatement(nodep);
 	iterateCheckBool(nodep,"Property",nodep->propp(),BOTH);	// it's like an if() condition.
 	userIterateAndNext(nodep->stmtsp(), NULL);
     }
-    virtual void visit(AstVAssert* nodep, AstNUser*) {
+    virtual void visit(AstVAssert* nodep) {
 	assertAtStatement(nodep);
 	iterateCheckBool(nodep,"Property",nodep->propp(),BOTH);	// it's like an if() condition.
 	userIterateAndNext(nodep->passsp(), NULL);
 	userIterateAndNext(nodep->failsp(), NULL);
     }
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	//if (debug()) nodep->dumpTree(cout,"-  PinPre: ");
 	// TOP LEVEL NODE
 	if (nodep->modVarp() && nodep->modVarp()->isGParam()) {
@@ -2172,7 +2172,7 @@ private:
 	}
 	//if (debug()) nodep->dumpTree(cout,"-  PinOut: ");
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	if (!m_paramsOnly) {
 	    if (nodep->modp()->castNotFoundModule()) {
 		// We've resolved parameters and hit a module that we couldn't resolve.  It's
@@ -2190,7 +2190,7 @@ private:
 	userIterateAndNext(nodep->paramsp(), NULL);
 	m_cellRangep = NULL;
     }
-    virtual void visit(AstGatePin* nodep, AstNUser*) {
+    virtual void visit(AstGatePin* nodep) {
 	if (m_vup->prelim()) {
 	    userIterateAndNext(nodep->rangep(), WidthVP(SELF,BOTH).p());
 	    userIterateAndNext(nodep->exprp(), WidthVP(CONTEXT,PRELIM).p());
@@ -2216,7 +2216,7 @@ private:
 	    pushDeletep(nodep); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	// Grab width from the output variable (if it's a function)
 	if (nodep->didWidth()) return;
 	UINFO(5,"  FTASK "<<nodep<<endl);
@@ -2238,7 +2238,7 @@ private:
 	nodep->doingWidth(false);
 	m_funcp = NULL;
     }
-    virtual void visit(AstReturn* nodep, AstNUser*) {
+    virtual void visit(AstReturn* nodep) {
 	// IEEE: Assignment-like context
 	assertAtStatement(nodep);
 	if (!m_funcp) {
@@ -2256,12 +2256,12 @@ private:
 	}
     }
 
-    virtual void visit(AstFuncRef* nodep, AstNUser*) {
-	visit(nodep->castNodeFTaskRef(), NULL);
+    virtual void visit(AstFuncRef* nodep) {
+	visit(nodep->castNodeFTaskRef());
 	nodep->dtypeFrom(nodep->taskp());
 	//if (debug()) nodep->dumpTree(cout,"  FuncOut: ");
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	// For arguments, is assignment-like context; see IEEE rules in AstNodeAssign
 	// Function hasn't been widthed, so make it so.
 	UINFO(5, "  FTASKREF "<<nodep<<endl);
@@ -2344,24 +2344,24 @@ private:
 	}
 	nodep->didWidth(true);
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	assertAtStatement(nodep);
 	m_initialp = nodep;
 	userIterateChildren(nodep, NULL);
 	m_initialp = NULL;
     }
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Iterate modules backwards, in bottom-up order.  That's faster
 	userIterateChildrenBackwards(nodep, NULL);
     }
 
     //--------------------
     // Default
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	nodep->v3fatalSrc("Visit function missing? Widthed function missing for math node: "<<nodep);
 	userIterateChildren(nodep, NULL);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	if (m_vup) nodep->v3fatalSrc("Visit function missing? Widthed expectation for this node: "<<nodep);
 	userIterateChildren(nodep, NULL);
diff --git a/src/V3WidthCommit.h b/src/V3WidthCommit.h
index 960ec7a74..f5cd9a4ef 100644
--- a/src/V3WidthCommit.h
+++ b/src/V3WidthCommit.h
@@ -37,13 +37,13 @@
 class WidthRemoveVisitor : public AstNVisitor {
 private:
     // VISITORS
-    virtual void visit(AstSigned* nodep, AstNUser*) {
+    virtual void visit(AstSigned* nodep) {
 	replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()); VL_DANGLING(nodep);
     }
-    virtual void visit(AstUnsigned* nodep, AstNUser*) {
+    virtual void visit(AstUnsigned* nodep) {
 	replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()); VL_DANGLING(nodep);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
     void replaceWithSignedVersion(AstNode* nodep, AstNode* newp) {
@@ -99,7 +99,7 @@ private:
 	// dtypep() figures into sameTree() results in better optimizations
 	if (!nodep) return NULL;
 	// Recurse to handle the data type, as may change the size etc of this type
-	if (!nodep->user1()) nodep->accept(*this,NULL);
+	if (!nodep->user1()) nodep->accept(*this);
 	// Look for duplicate
 	if (AstBasicDType* bdtypep = nodep->castBasicDType()) {
 	    AstBasicDType* newp = nodep->findInsertSameDType(bdtypep);
@@ -112,7 +112,7 @@ private:
 	return nodep;
     }
     // VISITORS
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	if (!nodep->dtypep()) nodep->v3fatalSrc("No dtype");
 	nodep->dtypep()->accept(*this);  // Do datatype first
 	if (AstConst* newp = newIfConstCommitSize(nodep)) {
@@ -124,15 +124,15 @@ private:
 	}
 	editDType(nodep);
     }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeDType* nodep) {
 	visitIterateNodeDType(nodep);
     }
-    virtual void visit(AstNodeClassDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeClassDType* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	visitIterateNodeDType(nodep);
 	nodep->clearCache();
     }
-    virtual void visit(AstParamTypeDType* nodep, AstNUser*) {
+    virtual void visit(AstParamTypeDType* nodep) {
 	if (nodep->user1SetOnce()) return;  // Process once
 	visitIterateNodeDType(nodep);
 	// Move to type table as all dtype pointers must resolve there
@@ -150,11 +150,11 @@ private:
 	nodep->iterateChildren(*this);
 	nodep->virtRefDTypep(editOneDType(nodep->virtRefDTypep()));
     }
-    virtual void visit(AstNodePreSel* nodep, AstNUser*) {
+    virtual void visit(AstNodePreSel* nodep) {
 	// This check could go anywhere after V3Param
 	nodep->v3fatalSrc("Presels should have been removed before this point");
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	editDType(nodep);
     }
diff --git a/src/V3WidthSel.cpp b/src/V3WidthSel.cpp
index ae544471d..09781af42 100644
--- a/src/V3WidthSel.cpp
+++ b/src/V3WidthSel.cpp
@@ -194,7 +194,7 @@ private:
     // VISITORS
     // If adding new visitors, insure V3Width's visit(TYPE) calls into here
 
-    virtual void visit(AstSelBit* nodep, AstNUser*) {
+    virtual void visit(AstSelBit* nodep) {
 	// Select of a non-width specified part of an array, i.e. "array[2]"
 	// This select style has a lsb and msb (no user specified width)
 	UINFO(6,"SELBIT "<<nodep<<endl);
@@ -273,7 +273,7 @@ private:
 	}
 	if (!rhsp->backp()) { pushDeletep(rhsp); VL_DANGLING(rhsp); }
     }
-    virtual void visit(AstSelExtract* nodep, AstNUser*) {
+    virtual void visit(AstSelExtract* nodep) {
 	// Select of a range specified part of an array, i.e. "array[2:3]"
 	// SELEXTRACT(from,msb,lsb) -> SEL(from, lsb, 1+msb-lsb)
 	// This select style has a (msb or lsb) and width
@@ -443,17 +443,17 @@ private:
 	if (!rhsp->backp()) { pushDeletep(rhsp); VL_DANGLING(rhsp); }
 	if (!widthp->backp()) { pushDeletep(widthp); VL_DANGLING(widthp); }
     }
-    virtual void visit(AstSelPlus* nodep, AstNUser*) {
+    virtual void visit(AstSelPlus* nodep) {
 	replaceSelPlusMinus(nodep);
     }
-    virtual void visit(AstSelMinus* nodep, AstNUser*) {
+    virtual void visit(AstSelMinus* nodep) {
 	replaceSelPlusMinus(nodep);
     }
     // If adding new visitors, insure V3Width's visit(TYPE) calls into here
 
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// See notes above; we never iterate
 	nodep->v3fatalSrc("Shouldn't iterate in V3WidthSel");
     }
diff --git a/src/astgen b/src/astgen
index 8c0463f62..60067dcc9 100755
--- a/src/astgen
+++ b/src/astgen
@@ -226,9 +226,9 @@ sub write_visitor {
     foreach my $type (sort (keys %Classes)) {
 	my $base = $Classes{$type};
 	if ($base) {
-	    printf $fh "    virtual void visit(Ast${type}* nodep, AstNUser* vup) { visit((Ast${base}*)(nodep),vup); }\n";
+	    printf $fh "    virtual void visit(Ast${type}* nodep) { visit((Ast${base}*)(nodep)); }\n";
 	} else {
-	    printf $fh "    virtual void visit(Ast${type}*, AstNUser*) = 0;\n";
+	    printf $fh "    virtual void visit(Ast${type}*) = 0;\n";
 	}
     }
     $fh->close();
@@ -596,7 +596,7 @@ sub tree_base {
 	# saves one comparison.
 	if ($out_for_type_sc[0]) {	# Short-circuited types
 	    $self->print("    // Generated by astgen with short-circuiting\n",
-			 "    virtual void visit(Ast${type}* nodep, AstNUser*) {\n",
+			 "    virtual void visit(Ast${type}* nodep) {\n",
 			 "	nodep->lhsp()->iterateAndNext(*this);\n",
 			 @out_for_type_sc);
 	    $self->print("	nodep->rhsp()->iterateAndNext(*this);\n",
@@ -608,7 +608,7 @@ sub tree_base {
 	    my $skip = $self->{tree_skip_visit}{$type};
 	    my $gen = $skip ? "Gen" : "";
 	    $self->print("    // Generated by astgen\n",
-			 "    virtual void visit$gen(Ast${type}* nodep, AstNUser*) {\n",
+			 "    virtual void visit$gen(Ast${type}* nodep) {\n",
 			 ($skip?"":
 			  "	nodep->iterateChildren(*this);\n"),
 			 @out_for_type,