From 94f7133c6ffec1f971221f6aff3c93924f1e5501 Mon Sep 17 00:00:00 2001
From: Wilson Snyder <wsnyder@wsnyder.org>
Date: Sun, 20 Oct 2019 11:49:41 -0400
Subject: [PATCH] Internals: make dump const. No functional change intended.

---
 src/V3Ast.cpp      |  15 ++++---
 src/V3Ast.h        |  28 ++++++------
 src/V3AstNodes.cpp | 106 ++++++++++++++++++++++-----------------------
 src/V3AstNodes.h   |  86 ++++++++++++++++++------------------
 4 files changed, 119 insertions(+), 116 deletions(-)

diff --git a/src/V3Ast.cpp b/src/V3Ast.cpp
index c925020df..cd0f70f9e 100644
--- a/src/V3Ast.cpp
+++ b/src/V3Ast.cpp
@@ -1034,7 +1034,7 @@ void AstNode::dumpPtrs(std::ostream& os) const {
     os<<endl;
 }
 
-void AstNode::dumpTree(std::ostream& os, const string& indent, int maxDepth) {
+void AstNode::dumpTree(std::ostream& os, const string& indent, int maxDepth) const {
     static int s_debugFileline = v3Global.opt.debugSrcLevel("fileline");  // --debugi-fileline 9
     os<<indent<<" "<<this<<endl;
     if (debug()>8) { os<<indent<<"     "; dumpPtrs(os); }
@@ -1044,25 +1044,26 @@ void AstNode::dumpTree(std::ostream& os, const string& indent, int maxDepth) {
     if (maxDepth==1) {
         if (op1p()||op2p()||op3p()||op4p()) { os<<indent<<"1: ...(maxDepth)"<<endl; }
     } else {
-        for (AstNode* nodep=op1p(); nodep; nodep=nodep->nextp()) {
+        for (const AstNode* nodep=op1p(); nodep; nodep=nodep->nextp()) {
             nodep->dumpTree(os, indent+"1:", maxDepth-1); }
-        for (AstNode* nodep=op2p(); nodep; nodep=nodep->nextp()) {
+        for (const AstNode* nodep=op2p(); nodep; nodep=nodep->nextp()) {
             nodep->dumpTree(os, indent+"2:", maxDepth-1); }
-        for (AstNode* nodep=op3p(); nodep; nodep=nodep->nextp()) {
+        for (const AstNode* nodep=op3p(); nodep; nodep=nodep->nextp()) {
             nodep->dumpTree(os, indent+"3:", maxDepth-1); }
-        for (AstNode* nodep=op4p(); nodep; nodep=nodep->nextp()) {
+        for (const AstNode* nodep=op4p(); nodep; nodep=nodep->nextp()) {
             nodep->dumpTree(os, indent+"4:", maxDepth-1); }
     }
 }
 
-void AstNode::dumpTreeAndNext(std::ostream& os, const string& indent, int maxDepth) {
+void AstNode::dumpTreeAndNext(std::ostream& os, const string& indent, int maxDepth) const {
     // Audited to make sure this is never NULL
-    for (AstNode* nodep=this; nodep; nodep=nodep->nextp()) {
+    for (const AstNode* nodep = this; nodep; nodep = nodep->nextp()) {
         nodep->dumpTree(os, indent, maxDepth);
     }
 }
 
 void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
+    // Not const function as calls checkTree
     if (doDump) {
         {   // Write log & close
             UINFO(2,"Dumping "<<filename<<endl);
diff --git a/src/V3Ast.h b/src/V3Ast.h
index f318f9262..590a98a4d 100644
--- a/src/V3Ast.h
+++ b/src/V3Ast.h
@@ -1439,7 +1439,7 @@ public:
     string warnMore() const { return fileline()->warnMore(); }
     string warnOther() const { return fileline()->warnOther(); }
 
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     void dumpGdb();  // For GDB only
     void dumpGdbHeader() const;
 
@@ -1474,10 +1474,10 @@ public:
     void checkIter() const;
     void clearIter() { m_iterpp = NULL; }
     void dumpPtrs(std::ostream& os=std::cout) const;
-    void dumpTree(std::ostream& os=std::cout, const string& indent="    ", int maxDepth=0);
-    void dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout, indent, maxDepth); }
+    void dumpTree(std::ostream& os=std::cout, const string& indent="    ", int maxDepth=0) const;
+    void dumpTree(const string& indent, int maxDepth=0) const { dumpTree(cout, indent, maxDepth); }
     void dumpTreeGdb();  // For GDB only
-    void dumpTreeAndNext(std::ostream& os=std::cout, const string& indent="    ", int maxDepth=0);
+    void dumpTreeAndNext(std::ostream& os=std::cout, const string& indent="    ", int maxDepth=0) const;
     void dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
     static void dumpTreeFileGdb(const char* filenamep=NULL);
 
@@ -1524,7 +1524,7 @@ public:
     //  AstAlways*      castAlways();
 };
 
-inline std::ostream& operator<<(std::ostream& os, AstNode* rhs) {
+inline std::ostream& operator<<(std::ostream& os, const AstNode* rhs) {
     if (!rhs) os<<"NULL"; else rhs->dump(os); return os;
 }
 inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
@@ -1871,7 +1871,7 @@ public:
         m_text = textp;  // Copy it
     }
     ASTNODE_BASE_FUNCS(NodeText)
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     virtual V3Hash sameHash() const { return V3Hash(text()); }
     virtual bool same(const AstNode* samep) const {
         const AstNodeText* asamep = static_cast<const AstNodeText*>(samep);
@@ -1897,8 +1897,8 @@ public:
     }
     ASTNODE_BASE_FUNCS(NodeDType)
     // ACCESSORS
-    virtual void dump(std::ostream& str);
-    virtual void dumpSmall(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
+    virtual void dumpSmall(std::ostream& str) const;
     virtual bool hasDType() const { return true; }
     virtual AstBasicDType* basicp() const = 0;  // (Slow) recurse down to find basic data type
     virtual AstNodeDType* skipRefp() const = 0;  // recurses over typedefs/const/enum to next non-typeref type
@@ -1958,7 +1958,7 @@ public:
     }
     ASTNODE_BASE_FUNCS(NodeClassDType)
     virtual const char* broken() const;
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     // For basicp() we reuse the size to indicate a "fake" basic type of same size
     virtual AstBasicDType* basicp() const {
         return (isFourstate()
@@ -2004,8 +2004,8 @@ public:
         m_refDTypep = NULL;
     }
     ASTNODE_BASE_FUNCS(NodeArrayDType)
-    virtual void dump(std::ostream& str);
-    virtual void dumpSmall(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
+    virtual void dumpSmall(std::ostream& str) const;
     virtual const char* broken() const {
         BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
                      || (!m_refDTypep && childDTypep()))); return NULL; }
@@ -2102,7 +2102,7 @@ public:
         cname(name);  // Might be overridden by dpi import/export
     }
     ASTNODE_BASE_FUNCS(NodeFTask)
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     virtual string name() const { return m_name; }  // * = Var name
     virtual bool maybePointedTo() const { return true; }
     virtual bool isGateOptimizable() const { return !((m_dpiExport || m_dpiImport) && !m_pure); }
@@ -2169,7 +2169,7 @@ public:
     virtual void cloneRelink() { if (m_taskp && m_taskp->clonep()) {
         m_taskp = m_taskp->clonep();
     }}
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     virtual string name() const { return m_name; }  // * = Var name
     virtual bool isGateOptimizable() const { return m_taskp && m_taskp->isGateOptimizable(); }
     string dotted() const { return m_dotted; }  // * = Scope name or ""
@@ -2218,7 +2218,7 @@ public:
         , m_internal(false), m_recursive(false), m_recursiveClone(false)
         , m_level(0), m_varNum(0), m_typeNum(0) { }
     ASTNODE_BASE_FUNCS(NodeModule)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual bool maybePointedTo() const { return true; }
     virtual string name() const { return m_name; }
     AstNode* stmtsp() const { return op2p(); }  // op2 = List of statements
diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp
index f15853914..17ccc32ee 100644
--- a/src/V3AstNodes.cpp
+++ b/src/V3AstNodes.cpp
@@ -823,7 +823,7 @@ void AstWhile::addNextStmt(AstNode* newp, AstNode* belowp) {
 //======================================================================
 // Per-type Debugging
 
-void AstNode::dump(std::ostream& str) {
+void AstNode::dump(std::ostream& str) const {
     str<<typeName()<<" "<<cvtToHex(this)
         //<<" "<<cvtToHex(this)->m_backp
        <<" <e"<<std::dec<<editCount()
@@ -850,45 +850,45 @@ void AstNode::dump(std::ostream& str) {
     }
 }
 
-void AstAlways::dump(std::ostream& str) {
+void AstAlways::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (keyword() != VAlwaysKwd::ALWAYS) str<<" ["<<keyword().ascii()<<"]";
 }
 
-void AstAttrOf::dump(std::ostream& str) {
+void AstAttrOf::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" ["<<attrType().ascii()<<"]";
 }
-void AstBasicDType::dump(std::ostream& str) {
+void AstBasicDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
     str<<" kwd="<<keyword().ascii();
     if (isRanged() && !rangep()) str<<" range=["<<left()<<":"<<right()<<"]";
 }
-void AstCCast::dump(std::ostream& str) {
+void AstCCast::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" sz"<<size();
 }
-void AstCell::dump(std::ostream& str) {
+void AstCell::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (recursive()) str<<" [RECURSIVE]";
     if (modp()) { str<<" -> "; modp()->dump(str); }
     else { str<<" ->UNLINKED:"<<modName(); }
 }
-void AstCellInline::dump(std::ostream& str) {
+void AstCellInline::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" -> "<<origModName();
 }
-void AstDisplay::dump(std::ostream& str) {
+void AstDisplay::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     //str<<" "<<displayType().ascii();
 }
-void AstEnumItemRef::dump(std::ostream& str) {
+void AstEnumItemRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" -> ";
     if (itemp()) { itemp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstIfaceRefDType::dump(std::ostream& str) {
+void AstIfaceRefDType::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (cellName()!="") { str<<" cell="<<cellName(); }
     if (ifaceName()!="") { str<<" if="<<ifaceName(); }
@@ -897,44 +897,44 @@ void AstIfaceRefDType::dump(std::ostream& str) {
     else if (ifacep()) { str<<" -> "; ifacep()->dump(str); }
     else { str<<" -> UNLINKED"; }
 }
-void AstIfaceRefDType::dumpSmall(std::ostream& str) {
+void AstIfaceRefDType::dumpSmall(std::ostream& str) const {
     this->AstNodeDType::dumpSmall(str);
     str<<"iface";
 }
-void AstJumpGo::dump(std::ostream& str) {
+void AstJumpGo::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" -> ";
     if (labelp()) { labelp()->dump(str); }
     else { str<<"%Error:UNLINKED"; }
 }
-void AstModportFTaskRef::dump(std::ostream& str) {
+void AstModportFTaskRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (isExport()) str<<" EXPORT";
     if (isImport()) str<<" IMPORT";
     if (ftaskp()) { str<<" -> "; ftaskp()->dump(str); }
     else { str<<" -> UNLINKED"; }
 }
-void AstModportVarRef::dump(std::ostream& str) {
+void AstModportVarRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (direction().isAny()) str<<" "<<direction();
     if (varp()) { str<<" -> "; varp()->dump(str); }
     else { str<<" -> UNLINKED"; }
 }
-void AstPin::dump(std::ostream& str) {
+void AstPin::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (modVarp()) { str<<" -> "; modVarp()->dump(str); }
     else { str<<" ->UNLINKED"; }
     if (svImplicit()) str<<" [.SV]";
 }
-void AstTypedef::dump(std::ostream& str) {
+void AstTypedef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (attrPublic()) str<<" [PUBLIC]";
 }
-void AstRange::dump(std::ostream& str) {
+void AstRange::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (littleEndian()) str<<" [LITTLE]";
 }
-void AstRefDType::dump(std::ostream& str) {
+void AstRefDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
     if (defp()) {
         static bool s_recursing = false;
@@ -946,12 +946,12 @@ void AstRefDType::dump(std::ostream& str) {
     }
     else { str<<" -> UNLINKED"; }
 }
-void AstNodeClassDType::dump(std::ostream& str) {
+void AstNodeClassDType::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (packed()) str<<" [PACKED]";
     if (isFourstate()) str<<" [4STATE]";
 }
-void AstNodeDType::dump(std::ostream& str) {
+void AstNodeDType::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (generic()) str<<" [GENERIC]";
     if (AstNodeDType* dtp = virtRefDTypep()) {
@@ -959,7 +959,7 @@ void AstNodeDType::dump(std::ostream& str) {
         dtp->dumpSmall(str);
     }
 }
-void AstNodeDType::dumpSmall(std::ostream& str) {
+void AstNodeDType::dumpSmall(std::ostream& str) const {
     str<<"("
        <<(generic()?"G/":"")
        <<((isSigned()&&!isDouble())?"s":"")
@@ -972,16 +972,16 @@ void AstNodeDType::dumpSmall(std::ostream& str) {
     if (!widthSized()) str<<"/"<<widthMin();
     str<<")";
 }
-void AstNodeArrayDType::dumpSmall(std::ostream& str) {
+void AstNodeArrayDType::dumpSmall(std::ostream& str) const {
     this->AstNodeDType::dumpSmall(str);
     if (VN_IS(this, PackArrayDType)) str<<"p"; else str<<"u";
     str<<declRange();
 }
-void AstNodeArrayDType::dump(std::ostream& str) {
+void AstNodeArrayDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
     str<<" "<<declRange();
 }
-void AstNodeModule::dump(std::ostream& str) {
+void AstNodeModule::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<"  L"<<level();
     if (modPublic()) str<<" [P]";
@@ -990,33 +990,33 @@ void AstNodeModule::dump(std::ostream& str) {
     if (recursiveClone()) str<<" [RECURSIVE-CLONE]";
     else if (recursive()) str<<" [RECURSIVE]";
 }
-void AstPackageExport::dump(std::ostream& str) {
+void AstPackageExport::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" -> "<<packagep();
 }
-void AstPackageImport::dump(std::ostream& str) {
+void AstPackageImport::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" -> "<<packagep();
 }
-void AstSel::dump(std::ostream& str) {
+void AstSel::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (declRange().ranged()) {
         str<<" decl"<<declRange()<<"]";
         if (declElWidth()!=1) str<<"/"<<declElWidth();
     }
 }
-void AstSliceSel::dump(std::ostream& str) {
+void AstSliceSel::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (declRange().ranged()) {
         str<<" decl"<<declRange();
     }
 }
-void AstMTaskBody::dump(std::ostream& str) {
+void AstMTaskBody::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" ";
     m_execMTaskp->dump(str);
 }
-void AstTypeTable::dump(std::ostream& str) {
+void AstTypeTable::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     for (int i=0; i < static_cast<int>(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
         if (AstBasicDType* subnodep = m_basicps[i]) {
@@ -1027,7 +1027,7 @@ void AstTypeTable::dump(std::ostream& str) {
         }
     }
     {
-        DetailedMap& mapr = m_detailedMap;
+        const DetailedMap& mapr = m_detailedMap;
         for (DetailedMap::const_iterator it = mapr.begin(); it != mapr.end(); ++it) {
             AstBasicDType* dtypep = it->second;
             str<<endl;  // Newline from caller, so newline first
@@ -1037,17 +1037,17 @@ void AstTypeTable::dump(std::ostream& str) {
     }
     // Note get newline from caller too.
 }
-void AstUnsizedArrayDType::dumpSmall(std::ostream& str) {
+void AstUnsizedArrayDType::dumpSmall(std::ostream& str) const {
     this->AstNodeDType::dumpSmall(str);
     str<<"[]";
 }
-void AstVarScope::dump(std::ostream& str) {
+void AstVarScope::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (isCircular()) str<<" [CIRC]";
     if (varp()) { str<<" -> "; varp()->dump(str); }
     else { str<<" ->UNLINKED"; }
 }
-void AstVarXRef::dump(std::ostream& str) {
+void AstVarXRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     if (lvalue()) str<<" [LV] => ";
@@ -1058,7 +1058,7 @@ void AstVarXRef::dump(std::ostream& str) {
     else if (varp()) { varp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstVarRef::dump(std::ostream& str) {
+void AstVarRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     if (lvalue()) str<<" [LV] => ";
@@ -1067,7 +1067,7 @@ void AstVarRef::dump(std::ostream& str) {
     else if (varp()) { varp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstVar::dump(std::ostream& str) {
+void AstVar::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (isSc()) str<<" [SC]";
     if (isPrimaryIO()) str<<(isInoutish()?" [PIO]":(isWritable()?" [PO]":" [PI]"));
@@ -1087,35 +1087,35 @@ void AstVar::dump(std::ostream& str) {
     if (!attrClocker().unknown()) str<<" ["<<attrClocker().ascii()<<"] ";
     str<<" "<<varType();
 }
-void AstSenTree::dump(std::ostream& str) {
+void AstSenTree::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (isMulti()) str<<" [MULTI]";
 }
-void AstSenItem::dump(std::ostream& str) {
+void AstSenItem::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" ["<<edgeType().ascii()<<"]";
 }
-void AstParseRef::dump(std::ostream& str) {
+void AstParseRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" ["<<expect().ascii()<<"]";
 }
-void AstPackageRef::dump(std::ostream& str) {
+void AstPackageRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     str<<" -> ";
     if (packagep()) { packagep()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstDot::dump(std::ostream& str) {
+void AstDot::dump(std::ostream& str) const {
     this->AstNode::dump(str);
 }
-void AstActive::dump(std::ostream& str) {
+void AstActive::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" => ";
     if (sensesp()) { sensesp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstNodeFTaskRef::dump(std::ostream& str) {
+void AstNodeFTaskRef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
     str<<" -> ";
@@ -1123,7 +1123,7 @@ void AstNodeFTaskRef::dump(std::ostream& str) {
     if (taskp()) { taskp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstNodeFTask::dump(std::ostream& str) {
+void AstNodeFTask::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (taskPublic()) str<<" [PUBLIC]";
     if (prototype()) str<<" [PROTOTYPE]";
@@ -1133,13 +1133,13 @@ void AstNodeFTask::dump(std::ostream& str) {
     if (dpiOpenParent()) str<<" [DPIOPENPARENT]";
     if ((dpiImport() || dpiExport()) && cname()!=name()) str<<" [c="<<cname()<<"]";
 }
-void AstBegin::dump(std::ostream& str) {
+void AstBegin::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (unnamed()) str<<" [UNNAMED]";
     if (generate()) str<<" [GEN]";
     if (genforp()) str<<" [GENFOR]";
 }
-void AstCoverDecl::dump(std::ostream& str) {
+void AstCoverDecl::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (this->dataDeclNullp()) {
         str<<" -> ";
@@ -1148,19 +1148,19 @@ void AstCoverDecl::dump(std::ostream& str) {
         if (binNum()) { str<<" bin"<<std::dec<<binNum(); }
     }
 }
-void AstCoverInc::dump(std::ostream& str) {
+void AstCoverInc::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" -> ";
     if (declp()) { declp()->dump(str); }
     else { str<<"%Error:UNLINKED"; }
 }
-void AstTraceInc::dump(std::ostream& str) {
+void AstTraceInc::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str<<" -> ";
     if (declp()) { declp()->dump(str); }
     else { str<<"%Error:UNLINKED"; }
 }
-void AstNodeText::dump(std::ostream& str) {
+void AstNodeText::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     string out = text();
     string::size_type pos;
@@ -1171,23 +1171,23 @@ void AstNodeText::dump(std::ostream& str) {
     str<<" \""<<out<<"\"";
 }
 
-void AstVFile::dump(std::ostream& str) {
+void AstVFile::dump(std::ostream& str) const {
     this->AstNode::dump(str);
 }
 
-void AstCFile::dump(std::ostream& str) {
+void AstCFile::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (source()) str<<" [SRC]";
     if (slow()) str<<" [SLOW]";
 }
-void AstCCall::dump(std::ostream& str) {
+void AstCCall::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (funcp()) {
         str<<" "<<funcp()->name()<<" => ";
         funcp()->dump(str);
     }
 }
-void AstCFunc::dump(std::ostream& str) {
+void AstCFunc::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (slow()) str<<" [SLOW]";
     if (pure()) str<<" [PURE]";
diff --git a/src/V3AstNodes.h b/src/V3AstNodes.h
index 516fc9033..3439c5843 100644
--- a/src/V3AstNodes.h
+++ b/src/V3AstNodes.h
@@ -178,7 +178,7 @@ public:
     int leftToRightInc() const { return littleEndian()?1:-1; }
     bool littleEndian() const { return m_littleEndian; }
     void littleEndian(bool flag) { m_littleEndian = flag; }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string emitC() { V3ERROR_NA; return ""; }
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(const AstNode* samep) const { return true; }
@@ -263,7 +263,7 @@ public:
         m_attrPublic = false;
     }
     ASTNODE_NODE_FUNCS(Typedef)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     AstNodeDType* getChildDTypep() const { return childDTypep(); }
     AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); }  // op1 = Type assigning to
     void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); }
@@ -410,7 +410,7 @@ public:
         const AstNodeArrayDType* asamep = static_cast<const AstNodeArrayDType*>(samep);
         return (subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp()));
     }
-    virtual void dumpSmall(std::ostream& str);
+    virtual void dumpSmall(std::ostream& str) const;
     virtual V3Hash sameHash() const { return V3Hash(m_refDTypep); }
     AstNodeDType* getChildDTypep() const { return childDTypep(); }
     AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); }  // op1 = Range of variable
@@ -498,7 +498,7 @@ private:
     }
 public:
     ASTNODE_NODE_FUNCS(BasicDType)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(m.m_keyword), V3Hash(m.m_nrange.hi())); }
     virtual bool same(const AstNode* samep) const {  // width/widthMin/numeric compared elsewhere
         const AstBasicDType* sp = static_cast<const AstBasicDType*>(samep);
@@ -614,8 +614,8 @@ public:
     ASTNODE_NODE_FUNCS(IfaceRefDType)
     // METHODS
     virtual const char* broken() const;
-    virtual void dump(std::ostream& str=std::cout);
-    virtual void dumpSmall(std::ostream& str);
+    virtual void dump(std::ostream& str=std::cout) const;
+    virtual void dumpSmall(std::ostream& str) const;
     virtual void cloneRelink();
     virtual AstBasicDType* basicp() const { return NULL; }
     virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; }
@@ -669,7 +669,7 @@ public:
     virtual bool similarDType(AstNodeDType* samep) const {
         return skipRefp()->similarDType(samep->skipRefp()); }
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_refDTypep), V3Hash(m_packagep)); }
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     virtual string name() const { return m_name; }
     virtual AstBasicDType* basicp() const { return subDTypep() ? subDTypep()->basicp() : NULL; }
     virtual AstNodeDType* skipRefp() const {
@@ -803,7 +803,7 @@ public:
         dtypeFrom(m_itemp);
     }
     ASTNODE_NODE_FUNCS(EnumItemRef)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string name() const { return itemp()->name(); }
     virtual const char* broken() const { BROKEN_RTN(!itemp()); return NULL; }
     virtual int instrCount() const { return 0; }
@@ -1017,7 +1017,7 @@ public:
         dtypeSetLogicSized(bitwidth, AstNumeric::UNSIGNED);
     }
     ASTNODE_NODE_FUNCS(Sel)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit, const V3Number& width) {
         out.opSel(from, bit.toUInt()+width.toUInt()-1, bit.toUInt()); }
     virtual string emitVerilog() { V3ERROR_NA; return ""; }  // Implemented specially
@@ -1042,6 +1042,7 @@ public:
     int lsbConst() const { return VN_CAST(lsbp(), Const)->toSInt(); }
     int msbConst() const { return lsbConst()+widthConst()-1; }
     VNumRange& declRange() { return m_declRange; }
+    const VNumRange& declRange() const { return m_declRange; }
     void declRange(const VNumRange& flag) { m_declRange = flag; }
     int declElWidth() const { return m_declElWidth; }
     void declElWidth(int flag) { m_declElWidth = flag; }
@@ -1060,7 +1061,7 @@ public:
                        new AstConst(fl, declRange.elements()))
         , m_declRange(declRange) { }
     ASTNODE_NODE_FUNCS(SliceSel)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& lo, const V3Number& width) {
         V3ERROR_NA; }
     virtual string emitVerilog() { V3ERROR_NA; return ""; }  // Implemented specially
@@ -1078,6 +1079,7 @@ public:
     AstNode* fromp() const { return op1p(); }  // op1 = Extracting what (NULL=TBD during parsing)
     // For widthConst()/loConst etc, see declRange().elements() and other VNumRange methods
     VNumRange& declRange() { return m_declRange; }
+    const VNumRange& declRange() const { return m_declRange; }
     void declRange(const VNumRange& flag) { m_declRange = flag; }
 };
 
@@ -1247,7 +1249,7 @@ public:
         m_declKwd = examplep->declKwd();
     }
     ASTNODE_NODE_FUNCS(Var)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string name() const { return m_name; }  // * = Var name
     virtual bool hasDType() const { return true; }
     virtual bool maybePointedTo() const { return true; }
@@ -1526,7 +1528,7 @@ public:
         BROKEN_RTN(m_scopep && !m_scopep->brokeExists()); return NULL; }
     virtual bool maybePointedTo() const { return true; }
     virtual string name() const {return scopep()->name()+"->"+varp()->name();}  // * = Var name
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual bool hasDType() const { return true; }
     AstVar* varp() const { return m_varp; }  // [After Link] Pointer to variable
     AstScope* scopep() const { return m_scopep; }  // Pointer to scope it's under
@@ -1553,7 +1555,7 @@ public:
         varScopep(varscp);
     }
     ASTNODE_NODE_FUNCS(VarRef)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(varp()->name()), V3Hash(hiername())); }
     virtual bool same(const AstNode* samep) const {
         return same(static_cast<const AstVarRef*>(samep)); }
@@ -1589,7 +1591,7 @@ public:
         dtypeFrom(varp);
     }
     ASTNODE_NODE_FUNCS(VarXRef)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     string dotted() const { return m_dotted; }
     void dotted(const string& dotted) { m_dotted = dotted; }
     string prettyDotted() const { return prettyName(dotted()); }
@@ -1635,7 +1637,7 @@ public:
         setNOp1p(exprp);
     }
     ASTNODE_NODE_FUNCS(Pin)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual const char* broken() const {
         BROKEN_RTN(m_modVarp && !m_modVarp->brokeExists());
         BROKEN_RTN(m_modPTypep && !m_modPTypep->brokeExists());
@@ -1739,7 +1741,7 @@ public:
     ASTNODE_NODE_FUNCS(PackageExport)
     virtual const char* broken() const { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_packagep && m_packagep->clonep()) m_packagep = m_packagep->clonep(); }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string name() const { return m_name; }
     AstPackage* packagep() const { return m_packagep; }
     void packagep(AstPackage* nodep) { m_packagep = nodep; }
@@ -1756,7 +1758,7 @@ public:
     ASTNODE_NODE_FUNCS(PackageImport)
     virtual const char* broken() const { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_packagep && m_packagep->clonep()) m_packagep = m_packagep->clonep(); }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string name() const { return m_name; }
     AstPackage* packagep() const { return m_packagep; }
     void packagep(AstPackage* nodep) { m_packagep = nodep; }
@@ -1784,7 +1786,7 @@ public:
         : AstNode(fl), m_name(name), m_export(isExport), m_ftaskp(NULL) { }
     ASTNODE_NODE_FUNCS(ModportFTaskRef)
     virtual const char* broken() const { BROKEN_RTN(m_ftaskp && !m_ftaskp->brokeExists()); return NULL; }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string name() const { return m_name; }
     virtual void cloneRelink() { if (m_ftaskp && m_ftaskp->clonep()) m_ftaskp = m_ftaskp->clonep(); }
     bool isImport() const { return !m_export; }
@@ -1806,7 +1808,7 @@ public:
         : AstNode(fl), m_name(name), m_direction(direction), m_varp(NULL) { }
     ASTNODE_NODE_FUNCS(ModportVarRef)
     virtual const char* broken() const { BROKEN_RTN(m_varp && !m_varp->brokeExists()); return NULL; }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual void cloneRelink() { if (m_varp && m_varp->clonep()) m_varp = m_varp->clonep(); }
     virtual string name() const { return m_name; }
     void direction(const VDirection& flag) { m_direction = flag; }
@@ -1851,7 +1853,7 @@ public:
         addNOp1p(pinsp); addNOp2p(paramsp); setNOp3p(rangep); }
     ASTNODE_NODE_FUNCS(Cell)
     // No cloneRelink, we presume cloneee's want the same module linkages
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual const char* broken() const { BROKEN_RTN(m_modp && !m_modp->brokeExists()); return NULL; }
     virtual bool maybePointedTo() const { return true; }
     // ACCESSORS
@@ -1892,7 +1894,7 @@ public:
         : AstNode(fl)
         , m_name(name), m_origModName(origModName), m_scopep(NULL) {}
     ASTNODE_NODE_FUNCS(CellInline)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual const char* broken() const { BROKEN_RTN(m_scopep && !m_scopep->brokeExists()); return NULL; }
     // ACCESSORS
     virtual string name() const { return m_name; }  // * = Cell name
@@ -2017,7 +2019,7 @@ public:
                 AstNode* lhsp, AstNodeFTaskRef* ftaskrefp)
         : AstNode(fl), m_expect(expect), m_name(name) { setNOp1p(lhsp); setNOp2p(ftaskrefp); }
     ASTNODE_NODE_FUNCS(ParseRef)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string name() const { return m_name; }  // * = Var name
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_expect), V3Hash(m_name)); }
     virtual bool same(const AstNode* samep) const {
@@ -2050,7 +2052,7 @@ public:
     virtual bool same(const AstNode* samep) const {
         return (m_packagep==static_cast<const AstPackageRef*>(samep)->m_packagep); }
     virtual V3Hash sameHash() const { return V3Hash(m_packagep); }
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     AstPackage* packagep() const { return m_packagep; }
     void packagep(AstPackage* nodep) { m_packagep = nodep; }
 };
@@ -2066,7 +2068,7 @@ public:
         if (!packagep) return rhsp;
         return new AstDot(fl, new AstPackageRef(fl, packagep), rhsp);
     }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string emitVerilog() { V3ERROR_NA; return ""; }
     virtual string emitC() { V3ERROR_NA; return ""; }
     AstNode* lhsp() const { return op1p(); }
@@ -2172,7 +2174,7 @@ public:
         m_edgeType = VEdgeType::ET_NEVER;
     }
     ASTNODE_NODE_FUNCS(SenItem)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual V3Hash sameHash() const { return V3Hash(edgeType()); }
     virtual bool same(const AstNode* samep) const {
         return edgeType()==static_cast<const AstSenItem*>(samep)->edgeType(); }
@@ -2225,7 +2227,7 @@ public:
         addNOp1p(sensesp);
     }
     ASTNODE_NODE_FUNCS(SenTree)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual bool maybePointedTo() const { return true; }
     virtual V3Hash sameHash() const { return V3Hash(); }
     bool isMulti() const { return m_multi; }
@@ -2248,7 +2250,7 @@ public:
     }
     ASTNODE_NODE_FUNCS(Always)
     //
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     AstSenTree* sensesp() const { return VN_CAST(op1p(), SenTree); }  // op1 = Sensitivity list
     AstNode* bodysp() const { return op2p(); }  // op2 = Statements to evaluate
     void addStmtp(AstNode* nodep) { addOp2p(nodep); }
@@ -2457,7 +2459,7 @@ public:
         }
         return NULL; }
     virtual void cloneRelink() { if (m_dataDeclp && m_dataDeclp->clonep()) m_dataDeclp = m_dataDeclp->clonep(); }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual int instrCount() const { return 1+2*instrCountLd(); }
     virtual bool maybePointedTo() const { return true; }
     int column() const { return m_column; }
@@ -2497,7 +2499,7 @@ public:
     ASTNODE_NODE_FUNCS(CoverInc)
     virtual const char* broken() const { BROKEN_RTN(!declp()->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_declp->clonep()) m_declp = m_declp->clonep(); }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual int instrCount() const { return 1+2*instrCountLd(); }
     virtual V3Hash sameHash() const { return V3Hash(declp()); }
     virtual bool same(const AstNode* samep) const {
@@ -2667,7 +2669,7 @@ public:
         m_displayType = dispType;
     }
     ASTNODE_NODE_FUNCS(Display)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual const char* broken() const { BROKEN_RTN(!fmtp()); return NULL; }
     virtual string verilogKwd() const { return (filep() ? string("$f")+string(displayType().ascii())
                                                 : string("$")+string(displayType().ascii())); }
@@ -3338,7 +3340,7 @@ public:
     ASTNODE_NODE_FUNCS(JumpGo)
     virtual const char* broken() const { BROKEN_RTN(!labelp()->brokeExistsAbove()); return NULL; }
     virtual void cloneRelink() { if (m_labelp->clonep()) m_labelp = m_labelp->clonep(); }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual int instrCount() const { return instrCountBranch(); }
     virtual V3Hash sameHash() const { return V3Hash(labelp()); }
     virtual bool same(const AstNode* samep) const {  // Also same if identical tree structure all the way down, but hard to detect
@@ -3411,7 +3413,7 @@ public:
         m_generate = generate;
     }
     ASTNODE_NODE_FUNCS(Begin)
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual string name() const { return m_name; }  // * = Block name
     virtual void name(const string& name) { m_name = name; }
     // op1 = Statements
@@ -3627,7 +3629,7 @@ public:
     ASTNODE_NODE_FUNCS(TraceInc)
     virtual const char* broken() const { BROKEN_RTN(!declp()->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_declp->clonep()) m_declp = m_declp->clonep(); }
-    virtual void dump(std::ostream& str);
+    virtual void dump(std::ostream& str) const;
     virtual int instrCount() const { return 10+2*instrCountLd(); }
     virtual bool hasDType() const { return true; }
     virtual V3Hash sameHash() const { return V3Hash(declp()); }
@@ -3660,7 +3662,7 @@ public:
         m_sensesp = sensesp;
     }
     ASTNODE_NODE_FUNCS(Active)
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     virtual string name() const { return m_name; }
     virtual const char* broken() const { BROKEN_RTN(m_sensesp && !m_sensesp->brokeExists()); return NULL; }
     virtual void cloneRelink() {
@@ -3699,7 +3701,7 @@ public:
     AstNode* dimp() const { return op2p(); }
     AstAttrType attrType() const { return m_attrType; }
     virtual V3Hash sameHash() const { return V3Hash(m_attrType); }
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
 };
 
 class AstScopeName : public AstNodeMath {
@@ -4232,7 +4234,7 @@ public:
     virtual V3Hash sameHash() const { return V3Hash(size()); }
     virtual bool same(const AstNode* samep) const {
         return size() == static_cast<const AstCCast*>(samep)->size(); }
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     //
     int size() const { return m_size; }
 };
@@ -5899,7 +5901,7 @@ public:
     AstVFile(FileLine* fl, const string& name)
         : AstFile(fl, name) { }
     ASTNODE_NODE_FUNCS(VFile)
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
 };
 
 //======================================================================
@@ -5920,7 +5922,7 @@ public:
         m_support = false;
     }
     ASTNODE_NODE_FUNCS(CFile)
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     bool slow() const { return m_slow; }
     void slow(bool flag) { m_slow = flag; }
     bool source() const { return m_source; }
@@ -5983,7 +5985,7 @@ public:
     virtual string name() const { return m_name; }
     virtual const char* broken() const { BROKEN_RTN((m_scopep && !m_scopep->brokeExists())); return NULL; }
     virtual bool maybePointedTo() const { return true; }
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(const AstNode* samep) const {
         const AstCFunc* asamep = static_cast<const AstCFunc*>(samep);
@@ -6075,7 +6077,7 @@ public:
         if (oldp->argsp()) addNOp1p(oldp->argsp()->unlinkFrBackWithNext());
     }
     ASTNODE_NODE_FUNCS(CCall)
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
     virtual void cloneRelink() { if (m_funcp && m_funcp->clonep()) {
         m_funcp = m_funcp->clonep();
     }}
@@ -6196,7 +6198,7 @@ public:
     void addStmtsp(AstNode* nodep) { addOp1p(nodep); }
     ExecMTask* execMTaskp() const { return m_execMTaskp; }
     void execMTaskp(ExecMTask* execMTaskp) { m_execMTaskp = execMTaskp; }
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
 };
 
 class AstExecGraph : public AstNode {
@@ -6253,7 +6255,7 @@ public:
     AstBasicDType* findInsertSameDType(AstBasicDType* nodep);
     void clearCache();
     void repairCache();
-    virtual void dump(std::ostream& str=std::cout);
+    virtual void dump(std::ostream& str=std::cout) const;
 };
 
 //######################################################################