Remove redundant 'virtual' keywords from overridden methods

'virtual' is redundant when 'override' is present, so keep only
'override'.

Add t/t_dist_cppstyle.pl to check for this.

include/verilated_fst_sc.h

@@ -52,35 +52,36 @@ public:
         }
         spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
     }
-    virtual ~VerilatedFstSc() /*override*/ { close(); }
+    ~VerilatedFstSc() override { close(); }
 
     // METHODS
     /// Called by SystemC simulate()
-    virtual void cycle(bool delta_cycle) {
+    void cycle(bool delta_cycle) override {
         if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
     }
 
     // Override VerilatedFstC. Must be called after starting simulation.
-    // cppcheck-suppress missingOverride  // GCC won't accept override
-    virtual void open(const char* filename) /*override*/ VL_MT_SAFE;
+    // Note: this is not a virtual function in the base class, so no 'override'
+    virtual void open(const char* filename) VL_MT_SAFE;
 
 private:
     /// Fake outs for linker
 
 #ifdef NC_SYSTEMC
     // Cadence Incisive has these as abstract functions so we must create them
-    virtual void set_time_unit(int exponent10_seconds) {}  // deprecated
+    void set_time_unit(int exponent10_seconds) override {}  // deprecated
 #endif
-    virtual void set_time_unit(double v, sc_time_unit tu) {}  // LCOV_EXCL_LINE
+    void set_time_unit(double v, sc_time_unit tu) override {}  // LCOV_EXCL_LINE
 
 //--------------------------------------------------
 // SystemC 2.1.v1
-#define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const std::string& name);
+#define DECL_TRACE_METHOD_A(tp) \
+    void trace(const tp& object, const std::string& name) override;
 #define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace(const tp& object, const std::string& name, int width);
+    void trace(const tp& object, const std::string& name, int width) override;
 
-    virtual void write_comment(const std::string&);
-    virtual void trace(const unsigned int&, const std::string&, const char**);
+    void write_comment(const std::string&) override;
+    void trace(const unsigned int&, const std::string&, const char**) override;
 
     // clang-format off
     // Formatting matches that of sc_trace.h

include/verilated_vcd_sc.h

@@ -55,35 +55,35 @@ public:
         spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
     }
     /// Destruct, flush, and close the dump
-    virtual ~VerilatedVcdSc() /*override*/ { close(); }
+    ~VerilatedVcdSc() override { close(); }
 
     // METHODS - for SC kernel
     // Called by SystemC simulate()
-    virtual void cycle(bool delta_cycle) {
+    void cycle(bool delta_cycle) override {
         if (!delta_cycle) this->dump(sc_time_stamp().to_double());
     }
 
     // Override VerilatedVcdC. Must be called after starting simulation.
-    // cppcheck-suppress missingOverride  // GCC won't accept override
-    virtual void open(const char* filename) /*override*/ VL_MT_SAFE;
+    void open(const char* filename) override VL_MT_SAFE;
 
 private:
     // METHODS - Fake outs for linker
 
 #ifdef NC_SYSTEMC
     // Cadence Incisive has these as abstract functions so we must create them
-    virtual void set_time_unit(int exponent10_seconds) {}  // deprecated
+    void set_time_unit(int exponent10_seconds) override {}  // deprecated
 #endif
-    virtual void set_time_unit(double v, sc_time_unit tu) {}  // LCOV_EXCL_LINE
+    void set_time_unit(double v, sc_time_unit tu) override {}  // LCOV_EXCL_LINE
 
 //--------------------------------------------------
 // SystemC 2.1.v1
-#define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const std::string& name);
+#define DECL_TRACE_METHOD_A(tp) \
+    void trace(const tp& object, const std::string& name) override;
 #define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace(const tp& object, const std::string& name, int width);
+    void trace(const tp& object, const std::string& name, int width) override;
 
-    virtual void write_comment(const std::string&);
-    virtual void trace(const unsigned int&, const std::string&, const char**);
+    void write_comment(const std::string&) override;
+    void trace(const unsigned int&, const std::string&, const char**) override;
 
     // clang-format off
     // Formatting matches that of sc_trace.h

src/V3Active.cpp

@@ -66,8 +66,8 @@ public:
         : V3GraphVertex{graphp}
         , m_name{name}
         , m_type{type} {}
-    virtual string name() const override { return m_name + " " + typestr(); }
-    virtual string dotColor() const override { return user() ? "green" : "black"; }
+    string name() const override { return m_name + " " + typestr(); }
+    string dotColor() const override { return user() ? "green" : "black"; }
     virtual int type() const { return m_type; }
 };
 
@@ -120,7 +120,7 @@ protected:
 
 public:
     LatchDetectGraph() { clear(); }
-    virtual ~LatchDetectGraph() override { clear(); }
+    ~LatchDetectGraph() override { clear(); }
     // ACCESSORS
     LatchDetectGraphVertex* currentp() { return m_curVertexp; }
     void currentp(LatchDetectGraphVertex* vertex) { m_curVertexp = vertex; }
@@ -219,7 +219,7 @@ private:
         m_scopep->addActivep(nodep);
     }
     // VISITORS
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         m_scopep = nodep;
         m_iActivep = nullptr;
         m_cActivep = nullptr;
@@ -227,13 +227,13 @@ private:
         iterateChildren(nodep);
         // Don't clear scopep, the namer persists beyond this visit
     }
-    virtual void visit(AstSenTree* nodep) override {
+    void visit(AstSenTree* nodep) override {
         // Simplify sensitivity list
         VL_DO_DANGLING(V3Const::constifyExpensiveEdit(nodep), nodep);
     }
     //--------------------
-    virtual void visit(AstNodeStmt*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeStmt*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // METHODS
@@ -275,7 +275,7 @@ public:
 
     // CONSTRUCTORS
     ActiveNamer() = default;
-    virtual ~ActiveNamer() override = default;
+    ~ActiveNamer() override = default;
     void main(AstScope* nodep) { iterate(nodep); }
 };
 
@@ -291,13 +291,13 @@ private:
     // STATE
     LatchDetectGraph m_graph;  // Graph used to detect latches in combo always
     // VISITORS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         const AstVar* const varp = nodep->varp();
         if (nodep->access().isWriteOrRW() && varp->isSignal() && !varp->isUsedLoopIdx()) {
             m_graph.addAssignment(nodep);
         }
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         if (!nodep->isBoundsCheck()) {
             LatchDetectGraphVertex* const parentp = m_graph.currentp();
             LatchDetectGraphVertex* const branchp = m_graph.addPathVertex(parentp, "BRANCH", true);
@@ -309,7 +309,7 @@ private:
         }
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -333,7 +333,7 @@ private:
     const CheckType m_check;  // Process type we are checking
 
     // VISITORS
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         // Non-blocking assignments are OK in sequential processes
         if (m_check == CT_SEQ) return;
 
@@ -357,7 +357,7 @@ private:
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
 
-    virtual void visit(AstAssign* nodep) override {
+    void visit(AstAssign* nodep) override {
         // Blocking assignments are always OK in combinational (and initial/final) processes
         if (m_check != CT_SEQ) return;
 
@@ -380,7 +380,7 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -407,7 +407,7 @@ private:
     bool m_itemSequent = false;  // Found a SenItem sequential
 
     // VISITORS
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         // Create required actives and add to scope
         UINFO(4, " SCOPE   " << nodep << endl);
         // Clear last scope's names, and collect this scope's existing names
@@ -415,10 +415,10 @@ private:
         m_scopeFinalp = nullptr;
         iterateChildren(nodep);
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         // Actives are being formed, so we can ignore any already made
     }
-    virtual void visit(AstInitialStatic* nodep) override {
+    void visit(AstInitialStatic* nodep) override {
         // Relink to IACTIVE, unless already under it
         UINFO(4, "    INITIAL " << nodep << endl);
         const ActiveDlyVisitor dlyvisitor{nodep, ActiveDlyVisitor::CT_INITIAL};
@@ -426,7 +426,7 @@ private:
         nodep->unlinkFrBack();
         wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstInitial* nodep) override {
+    void visit(AstInitial* nodep) override {
         // Relink to IACTIVE, unless already under it
         UINFO(4, "    INITIAL " << nodep << endl);
         const ActiveDlyVisitor dlyvisitor{nodep, ActiveDlyVisitor::CT_INITIAL};
@@ -434,28 +434,28 @@ private:
         nodep->unlinkFrBack();
         wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep) override {
+    void visit(AstAssignAlias* nodep) override {
         // Relink to CACTIVE, unless already under it
         UINFO(4, "    ASSIGNW " << nodep << endl);
         AstActive* const wantactivep = m_namer.getCActive(nodep->fileline());
         nodep->unlinkFrBack();
         wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         // Relink to CACTIVE, unless already under it
         UINFO(4, "    ASSIGNW " << nodep << endl);
         AstActive* const wantactivep = m_namer.getCActive(nodep->fileline());
         nodep->unlinkFrBack();
         wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstCoverToggle* nodep) override {
+    void visit(AstCoverToggle* nodep) override {
         // Relink to CACTIVE, unless already under it
         UINFO(4, "    COVERTOGGLE " << nodep << endl);
         AstActive* const wantactivep = m_namer.getCActive(nodep->fileline());
         nodep->unlinkFrBack();
         wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstFinal* nodep) override {
+    void visit(AstFinal* nodep) override {
         // Relink to CFUNC for the final
         UINFO(4, "    FINAL " << nodep << endl);
         if (!nodep->bodysp()) {  // Empty, Kill it.
@@ -537,7 +537,7 @@ private:
             ActiveDlyVisitor{nodep, ActiveDlyVisitor::CT_SEQ};
         }
     }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         // Move always to appropriate ACTIVE based on its sense list
         UINFO(4, "    ALW   " << nodep << endl);
         // if (debug() >= 9) nodep->dumpTree(cout, "  Alw: ");
@@ -549,7 +549,7 @@ private:
         }
         visitAlways(nodep, nodep->sensesp(), nodep->keyword());
     }
-    virtual void visit(AstAlwaysPostponed* nodep) override {
+    void visit(AstAlwaysPostponed* nodep) override {
         UINFO(4, "    ALW   " << nodep << endl);
         if (!nodep->bodysp()) {
             VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
@@ -557,13 +557,13 @@ private:
         }
         visitAlways(nodep, nullptr, VAlwaysKwd::ALWAYS);
     }
-    virtual void visit(AstAlwaysPublic* nodep) override {
+    void visit(AstAlwaysPublic* nodep) override {
         // 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(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         if (nodep->varrefp()) {
             if (const AstBasicDType* const basicp = nodep->varrefp()->dtypep()->basicp()) {
                 if (basicp->isEventValue()) {
@@ -592,9 +592,9 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstVarScope*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstVarScope*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS

src/V3ActiveTop.cpp

@@ -52,13 +52,13 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // Create required actives and add to module
         // We can start ordering at a module, or a scope
         UINFO(4, " MOD   " << nodep << endl);
         iterateChildren(nodep);
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         UINFO(4, "   ACTIVE " << nodep << endl);
         // Remove duplicate clocks and such; sensesp() may change!
         V3Const::constifyExpensiveEdit(nodep);
@@ -101,27 +101,27 @@ private:
         // No need to do statements under it, they're already moved.
         // iterateChildren(nodep);
     }
-    virtual void visit(AstNodeProcedure* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstNodeProcedure* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAssignAlias* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstAssignAlias* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAssignW* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstAssignW* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAlwaysPublic* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstAlwaysPublic* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
     //--------------------
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstVarScope*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstVarScope*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit ActiveTopVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~ActiveTopVisitor() override = default;
+    ~ActiveTopVisitor() override = default;
 };
 
 //######################################################################

src/V3Assert.cpp

@@ -196,7 +196,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstIf* nodep) override {
+    void visit(AstIf* nodep) override {
         if (nodep->user1SetOnce()) return;
         if (nodep->uniquePragma() || nodep->unique0Pragma()) {
             const AstNodeIf* ifp = nodep;
@@ -254,7 +254,7 @@ private:
     }
 
     //========== Case assertions
-    virtual void visit(AstCase* nodep) override {
+    void visit(AstCase* nodep) override {
         iterateChildren(nodep);
         if (!nodep->user1SetOnce()) {
             bool has_default = false;
@@ -323,7 +323,7 @@ private:
     }
 
     //========== Past
-    virtual void visit(AstPast* nodep) override {
+    void visit(AstPast* nodep) override {
         iterateChildren(nodep);
         uint32_t ticks = 1;
         if (nodep->ticksp()) {
@@ -353,13 +353,13 @@ private:
         }
         nodep->replaceWith(inp);
     }
-    virtual void visit(AstSampled* nodep) override {
+    void visit(AstSampled* nodep) override {
         nodep->replaceWith(nodep->exprp()->unlinkFrBack());
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
 
     //========== Statements
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisplay* nodep) override {
         iterateChildren(nodep);
         // Replace the special types with standard text
         if (nodep->displayType() == VDisplayType::DT_INFO) {
@@ -410,32 +410,32 @@ private:
             m_modp->addStmtp(newp);
         }
     }
-    virtual void visit(AstMonitorOff* nodep) override {
+    void visit(AstMonitorOff* nodep) override {
         const auto newp
             = new AstAssign(nodep->fileline(), newMonitorOffVarRefp(nodep, VAccess::WRITE),
                             new AstConst(nodep->fileline(), AstConst::BitTrue{}, nodep->off()));
         nodep->replaceWith(newp);
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstAssert* nodep) override {
+    void visit(AstAssert* nodep) override {
         iterateChildren(nodep);
         newPslAssertion(nodep, nodep->failsp());
     }
-    virtual void visit(AstAssertIntrinsic* nodep) override {
+    void visit(AstAssertIntrinsic* nodep) override {
         iterateChildren(nodep);
         newPslAssertion(nodep, nodep->failsp());
     }
-    virtual void visit(AstCover* nodep) override {
+    void visit(AstCover* nodep) override {
         iterateChildren(nodep);
         newPslAssertion(nodep, nullptr);
     }
-    virtual void visit(AstRestrict* nodep) override {
+    void visit(AstRestrict* nodep) override {
         iterateChildren(nodep);
         // IEEE says simulator ignores these
         VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
     }
 
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         VL_RESTORER(m_modPastNum);
         VL_RESTORER(m_modStrobeNum);
@@ -446,7 +446,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstBegin* nodep) override {
+    void visit(AstBegin* nodep) override {
         // This code is needed rather than a visitor in V3Begin,
         // because V3Assert is called before V3Begin
         VL_RESTORER(m_beginp);
@@ -456,12 +456,12 @@ private:
         }
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit AssertVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~AssertVisitor() override {
+    ~AssertVisitor() override {
         V3Stats::addStat("Assertions, assert non-immediate statements", m_statAsNotImm);
         V3Stats::addStat("Assertions, assert immediate statements", m_statAsImm);
         V3Stats::addStat("Assertions, cover statements", m_statCover);

src/V3AssertPre.cpp

@@ -69,7 +69,7 @@ private:
 
     // VISITORS
     //========== Statements
-    virtual void visit(AstClocking* nodep) override {
+    void visit(AstClocking* nodep) override {
         UINFO(8, "   CLOCKING" << nodep << endl);
         // Store the new default clock, reset on new module
         m_seniDefaultp = nodep->sensesp();
@@ -81,14 +81,14 @@ private:
         }
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         iterateAndNextNull(nodep->sensesp());
         if (nodep->sensesp()) m_seniAlwaysp = nodep->sensesp()->sensesp();
         iterateAndNextNull(nodep->bodysp());
         m_seniAlwaysp = nullptr;
     }
 
-    virtual void visit(AstNodeCoverOrAssert* nodep) override {
+    void visit(AstNodeCoverOrAssert* nodep) override {
         if (nodep->sentreep()) return;  // Already processed
         clearAssertInfo();
         // Find Clocking's buried under nodep->exprsp
@@ -96,7 +96,7 @@ private:
         if (!nodep->immediate()) nodep->sentreep(newSenTree(nodep));
         clearAssertInfo();
     }
-    virtual void visit(AstFell* nodep) override {
+    void visit(AstFell* nodep) override {
         if (nodep->sentreep()) return;  // Already processed
         iterateChildren(nodep);
         FileLine* const fl = nodep->fileline();
@@ -110,12 +110,12 @@ private:
         nodep->sentreep(newSenTree(nodep));
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstPast* nodep) override {
+    void visit(AstPast* nodep) override {
         if (nodep->sentreep()) return;  // Already processed
         iterateChildren(nodep);
         nodep->sentreep(newSenTree(nodep));
     }
-    virtual void visit(AstRose* nodep) override {
+    void visit(AstRose* nodep) override {
         if (nodep->sentreep()) return;  // Already processed
         iterateChildren(nodep);
         FileLine* const fl = nodep->fileline();
@@ -129,7 +129,7 @@ private:
         nodep->sentreep(newSenTree(nodep));
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstStable* nodep) override {
+    void visit(AstStable* nodep) override {
         if (nodep->sentreep()) return;  // Already processed
         iterateChildren(nodep);
         FileLine* const fl = nodep->fileline();
@@ -143,7 +143,7 @@ private:
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
 
-    virtual void visit(AstImplication* nodep) override {
+    void visit(AstImplication* nodep) override {
         if (nodep->sentreep()) return;  // Already processed
 
         FileLine* const fl = nodep->fileline();
@@ -161,7 +161,7 @@ private:
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
 
-    virtual void visit(AstPropClocked* nodep) override {
+    void visit(AstPropClocked* nodep) override {
         // No need to iterate the body, once replace will get iterated
         iterateAndNextNull(nodep->sensesp());
         if (m_senip)
@@ -183,12 +183,12 @@ private:
         nodep->replaceWith(blockp);
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         iterateChildren(nodep);
         // Reset defaults
         m_seniDefaultp = nullptr;
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -197,7 +197,7 @@ public:
         // Process
         iterate(nodep);
     }
-    virtual ~AssertPreVisitor() override = default;
+    ~AssertPreVisitor() override = default;
 };
 
 //######################################################################

src/V3AstNodes.cpp

@@ -564,11 +564,11 @@ string AstVar::dpiArgType(bool named, bool forReturn) const {
         return dpiTypesToStringConverter{}.convert(this);
     } else {
         class converter final : public dpiTypesToStringConverter {
-            virtual string bitLogicVector(const AstVar* varp, bool isBit) const override {
+            string bitLogicVector(const AstVar* varp, bool isBit) const override {
                 return string(varp->isReadOnly() ? "const " : "")
                        + dpiTypesToStringConverter::bitLogicVector(varp, isBit) + '*';
             }
-            virtual string primitive(const AstVar* varp) const override {
+            string primitive(const AstVar* varp) const override {
                 string type = dpiTypesToStringConverter::primitive(varp);
                 if (varp->isWritable() || VN_IS(varp->dtypep()->skipRefp(), UnpackArrayDType)) {
                     if (!varp->isWritable() && varp->basicp()->keyword() != VBasicDTypeKwd::STRING)
@@ -600,16 +600,16 @@ string AstVar::dpiTmpVarType(const string& varName) const {
                 return "";
             }
         }
-        virtual string openArray(const AstVar* varp) const override {
+        string openArray(const AstVar* varp) const override {
             return dpiTypesToStringConverter::openArray(varp) + ' ' + m_name
                    + arraySuffix(varp, 0);
         }
-        virtual string bitLogicVector(const AstVar* varp, bool isBit) const override {
+        string bitLogicVector(const AstVar* varp, bool isBit) const override {
             string type = dpiTypesToStringConverter::bitLogicVector(varp, isBit);
             type += ' ' + m_name + arraySuffix(varp, varp->widthWords());
             return type;
         }
-        virtual string primitive(const AstVar* varp) const override {
+        string primitive(const AstVar* varp) const override {
             string type = dpiTypesToStringConverter::primitive(varp);
             if (varp->isWritable() || VN_IS(varp->dtypep()->skipRefp(), UnpackArrayDType)) {
                 if (!varp->isWritable() && varp->basicp()->keyword() == VBasicDTypeKwd::CHANDLE)

src/V3Begin.cpp

@@ -120,14 +120,14 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         UINFO(8, "  " << nodep << endl);
         // Rename it
         if (m_unnamedScope != "") {
@@ -162,7 +162,7 @@ private:
             m_ftaskp = nullptr;
         }
     }
-    virtual void visit(AstBegin* nodep) override {
+    void visit(AstBegin* nodep) override {
         // Begin blocks were only useful in variable creation, change names and delete
         UINFO(8, "  " << nodep << endl);
         VL_RESTORER(m_displayScope);
@@ -191,7 +191,7 @@ private:
             VL_DO_DANGLING(pushDeletep(nodep), nodep);
         }
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (m_unnamedScope != "") {
             // Rename it
             nodep->name(dot(m_unnamedScope, nodep->name()));
@@ -200,7 +200,7 @@ private:
             liftNode(nodep);
         }
     }
-    virtual void visit(AstTypedef* nodep) override {
+    void visit(AstTypedef* nodep) override {
         if (m_unnamedScope != "") {
             // Rename it
             nodep->name(dot(m_unnamedScope, nodep->name()));
@@ -209,7 +209,7 @@ private:
             liftNode(nodep);
         }
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         UINFO(8, "   CELL " << nodep << endl);
         if (m_namedScope != "") {
             m_statep->userMarkChanged(nodep);
@@ -222,14 +222,14 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         UINFO(9, "   VARXREF " << nodep << endl);
         if (m_namedScope != "" && nodep->inlinedDots() == "" && !m_ftaskp) {
             nodep->inlinedDots(m_namedScope);
             UINFO(9, "    rescope to " << nodep << endl);
         }
     }
-    virtual void visit(AstScopeName* nodep) override {
+    void visit(AstScopeName* nodep) override {
         // 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
@@ -244,13 +244,13 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstCoverDecl* nodep) override {
+    void visit(AstCoverDecl* nodep) override {
         // Don't need to fix path in coverage statements, they're not under
         // any BEGINs, but V3Coverage adds them all under the module itself.
         iterateChildren(nodep);
     }
     // VISITORS - LINT CHECK
-    virtual void visit(AstIf* nodep) override {  // not AstNodeIf; other types not covered
+    void visit(AstIf* nodep) override {  // not AstNodeIf; other types not covered
         // Check IFDEPTH warning - could be in other transform files if desire
         VL_RESTORER(m_ifDepth);
         if (m_ifDepth == -1 || v3Global.opt.ifDepth() < 1) {  // Turned off
@@ -264,7 +264,7 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -272,7 +272,7 @@ public:
         : m_statep{statep} {
         iterate(nodep);
     }
-    virtual ~BeginVisitor() override = default;
+    ~BeginVisitor() override = default;
 };
 
 //######################################################################
@@ -285,21 +285,21 @@ private:
     //   AstNodeFTask::user1p           // Node replaced, rename it
 
     // VISITORS
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         if (nodep->taskp()->user1()) {  // It was converted
             UINFO(9, "    relinkFTask " << nodep << endl);
             nodep->name(nodep->taskp()->name());
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (nodep->varp()->user1()) {  // It was converted
             UINFO(9, "    relinVarRef " << nodep << endl);
             nodep->name(nodep->varp()->name());
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstIfaceRefDType* nodep) override {
+    void visit(AstIfaceRefDType* nodep) override {
         // May have changed cell names
         // TypeTable is always after all modules, so names are stable
         UINFO(8, "   IFACEREFDTYPE " << nodep << endl);
@@ -308,12 +308,12 @@ private:
         iterateChildren(nodep);
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     BeginRelinkVisitor(AstNetlist* nodep, BeginState*) { iterate(nodep); }
-    virtual ~BeginRelinkVisitor() override = default;
+    ~BeginRelinkVisitor() override = default;
 };
 
 //######################################################################

src/V3Branch.cpp

@@ -63,7 +63,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         UINFO(4, " IF: " << nodep << endl);
         VL_RESTORER(m_likely);
         VL_RESTORER(m_unlikely);
@@ -87,17 +87,17 @@ private:
             }  // else leave unknown
         }
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         checkUnlikely(nodep);
         nodep->funcp()->user1Inc();
         iterateChildren(nodep);
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         checkUnlikely(nodep);
         m_cfuncsp.push_back(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         checkUnlikely(nodep);
         iterateChildren(nodep);
     }
@@ -116,7 +116,7 @@ public:
         iterateChildren(nodep);
         calc_tasks();
     }
-    virtual ~BranchVisitor() override = default;
+    ~BranchVisitor() override = default;
 };
 
 //######################################################################

src/V3Broken.cpp

@@ -214,27 +214,27 @@ private:
         }
         return false;
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         processAndIterate(nodep);
         UASSERT_OBJ(!(v3Global.assertDTypesResolved() && nodep->brokeLhsMustBeLvalue()
                       && VN_IS(nodep->lhsp(), NodeVarRef)
                       && !VN_AS(nodep->lhsp(), NodeVarRef)->access().isWriteOrRW()),
                     nodep, "Assignment LHS is not an lvalue");
     }
-    virtual void visit(AstRelease* nodep) override {
+    void visit(AstRelease* nodep) override {
         processAndIterate(nodep);
         UASSERT_OBJ(!(v3Global.assertDTypesResolved() && VN_IS(nodep->lhsp(), NodeVarRef)
                       && !VN_AS(nodep->lhsp(), NodeVarRef)->access().isWriteOrRW()),
                     nodep, "Release LHS is not an lvalue");
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         VL_RESTORER(m_inScope);
         {
             m_inScope = true;
             processAndIterate(nodep);
         }
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         processAndIterate(nodep);
         // m_inScope because some Vars have initial variable references without scopes
         // This might false fire with some debug flags, as not certain we don't have temporary
@@ -252,7 +252,7 @@ private:
             }
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         UASSERT_OBJ(!m_cfuncp, nodep, "Nested AstCFunc");
         m_cfuncp = nodep;
         m_localVars.clear();
@@ -270,7 +270,7 @@ private:
 
         m_cfuncp = nullptr;
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         // Each branch is a separate local variable scope
         pushLocalScope();
         processEnter(nodep);
@@ -288,21 +288,21 @@ private:
         processExit(nodep);
         popLocalScope();
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         // For local variable checking act as if any statement introduces a new scope.
         // This is aggressive but conservatively correct.
         pushLocalScope();
         processAndIterate(nodep);
         popLocalScope();
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         processAndIterate(nodep);
         if (m_cfuncp) {
             m_localVars.insert(nodep);
             m_localsStack.back().insert(nodep);
         }
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         // Process not just iterate
         processAndIterate(nodep);
     }
@@ -310,7 +310,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit BrokenCheckVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~BrokenCheckVisitor() override = default;
+    ~BrokenCheckVisitor() override = default;
 };
 
 //######################################################################

src/V3CUse.cpp

@@ -57,7 +57,7 @@ class CUseVisitor final : public VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstClassRefDType* nodep) override {
+    void visit(AstClassRefDType* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         if (!m_impOnly) addNewUse(nodep, VUseType::INT_FWD_CLASS, nodep->classp()->name());
         // Need to include extends() when we implement, but no need for pointers to know
@@ -67,17 +67,17 @@ class CUseVisitor final : public VNVisitor {
             iterateChildren(nodep->classp());  // This also gets all extend classes
         }
     }
-    virtual void visit(AstNodeDType* nodep) override {
+    void visit(AstNodeDType* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         if (nodep->virtRefDTypep()) iterate(nodep->virtRefDTypep());
         if (nodep->virtRefDType2p()) iterate(nodep->virtRefDType2p());
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         if (nodep->dtypep() && !nodep->dtypep()->user1()) iterate(nodep->dtypep());
         iterateChildren(nodep);
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         // Currently no IMP_INCLUDE because we include __Syms which has them all
         addNewUse(nodep, VUseType::INT_FWD_CLASS, nodep->modp()->name());
@@ -90,7 +90,7 @@ public:
         : m_modp(modp) {
         iterate(modp);
     }
-    virtual ~CUseVisitor() override = default;
+    ~CUseVisitor() override = default;
     VL_UNCOPYABLE(CUseVisitor);
 };
 

src/V3Case.cpp

@@ -59,7 +59,7 @@ private:
     // METHODS
     VL_DEBUG_FUNC;  // Declare debug()
 
-    virtual void visit(AstNodeCase* nodep) override {
+    void visit(AstNodeCase* nodep) override {
         if (VN_IS(nodep, Case) && VN_AS(nodep, Case)->casex()) {
             nodep->v3warn(CASEX, "Suggest casez (with ?'s) in place of casex (with X's)");
         }
@@ -86,7 +86,7 @@ private:
             m_caseExprp = nullptr;
         }
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         // See also neverItem
         if (m_caseExprp && nodep->num().isFourState()) {
             if (VN_IS(m_caseExprp, GenCase)) {
@@ -107,12 +107,12 @@ private:
             }
         }
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit CaseLintVisitor(AstNodeCase* nodep) { iterate(nodep); }
-    virtual ~CaseLintVisitor() override = default;
+    ~CaseLintVisitor() override = default;
 };
 
 //######################################################################
@@ -493,7 +493,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCase* nodep) override {
+    void visit(AstCase* nodep) override {
         V3Case::caseLint(nodep);
         iterateChildren(nodep);
         if (debug() >= 9) nodep->dumpTree(cout, " case_old: ");
@@ -510,7 +510,7 @@ private:
         }
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         if (VN_IS(nodep, Always)) m_alwaysp = nodep;
         iterateChildren(nodep);
     }
@@ -521,7 +521,7 @@ public:
         for (auto& itr : m_valueItem) itr = nullptr;
         iterate(nodep);
     }
-    virtual ~CaseVisitor() override {
+    ~CaseVisitor() override {
         V3Stats::addStat("Optimizations, Cases parallelized", m_statCaseFast);
         V3Stats::addStat("Optimizations, Cases complex", m_statCaseSlow);
     }

src/V3Cast.cpp

@@ -111,25 +111,25 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeUniop* nodep) override {
+    void visit(AstNodeUniop* nodep) override {
         iterateChildren(nodep);
         nodep->user1(nodep->lhsp()->user1());
         if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
     }
-    virtual void visit(AstNodeBiop* nodep) override {
+    void visit(AstNodeBiop* nodep) override {
         iterateChildren(nodep);
         nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1());
         if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
         if (nodep->sizeMattersRhs()) ensureCast(nodep->rhsp());
     }
-    virtual void visit(AstNodeTriop* nodep) override {
+    void visit(AstNodeTriop* nodep) override {
         iterateChildren(nodep);
         nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1() | nodep->thsp()->user1());
         if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
         if (nodep->sizeMattersRhs()) ensureCast(nodep->rhsp());
         if (nodep->sizeMattersThs()) ensureCast(nodep->thsp());
     }
-    virtual void visit(AstNodeQuadop* nodep) override {
+    void visit(AstNodeQuadop* nodep) override {
         iterateChildren(nodep);
         nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1() | nodep->thsp()->user1()
                      | nodep->fhsp()->user1());
@@ -138,12 +138,12 @@ private:
         if (nodep->sizeMattersThs()) ensureCast(nodep->thsp());
         if (nodep->sizeMattersFhs()) ensureCast(nodep->fhsp());
     }
-    virtual void visit(AstCCast* nodep) override {
+    void visit(AstCCast* nodep) override {
         iterateChildren(nodep);
         ensureLower32Cast(nodep);
         nodep->user1(1);
     }
-    virtual void visit(AstNegate* nodep) override {
+    void visit(AstNegate* nodep) override {
         iterateChildren(nodep);
         nodep->user1(nodep->lhsp()->user1());
         if (nodep->lhsp()->widthMin() == 1) {
@@ -155,7 +155,7 @@ private:
             ensureCast(nodep->lhsp());
         }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         const AstNode* const backp = nodep->backp();
         if (nodep->access().isReadOnly() && !VN_IS(backp, CCast) && VN_IS(backp, NodeMath)
             && !VN_IS(backp, ArraySel) && !VN_IS(backp, RedXor) && backp->width()
@@ -166,7 +166,7 @@ private:
         }
         nodep->user1(1);
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         // Constants are of unknown size if smaller than 33 bits, because
         // we're too lazy to wrap every constant in the universe in
         // ((IData)#).
@@ -174,29 +174,29 @@ private:
     }
 
     // Null dereference protection
-    virtual void visit(AstNullCheck* nodep) override {
+    void visit(AstNullCheck* nodep) override {
         iterateChildren(nodep);
         nodep->user1(nodep->lhsp()->user1());
     }
-    virtual void visit(AstCMethodCall* nodep) override {
+    void visit(AstCMethodCall* nodep) override {
         iterateChildren(nodep);
         ensureNullChecked(nodep->fromp());
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         iterateChildren(nodep);
         ensureNullChecked(nodep->fromp());
     }
 
     // NOPs
-    virtual void visit(AstVar*) override {}
+    void visit(AstVar*) override {}
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit CastVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~CastVisitor() override = default;
+    ~CastVisitor() override = default;
 };
 
 //######################################################################

src/V3Cdc.cpp

@@ -67,9 +67,9 @@ public:
         , m_srcDomainSet{false}
         , m_dstDomainSet{false}
         , m_asyncPath{false} {}
-    virtual ~CdcEitherVertex() override = default;
+    ~CdcEitherVertex() override = default;
     // ACCESSORS
-    virtual FileLine* fileline() const override { return nodep()->fileline(); }
+    FileLine* fileline() const override { return nodep()->fileline(); }
     AstScope* scopep() const { return m_scopep; }
     AstNode* nodep() const { return m_nodep; }
     AstSenTree* srcDomainp() const { return m_srcDomainp; }
@@ -93,11 +93,11 @@ public:
     CdcVarVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
         : CdcEitherVertex{graphp, scopep, varScp}
         , m_varScp{varScp} {}
-    virtual ~CdcVarVertex() override = default;
+    ~CdcVarVertex() override = default;
     // ACCESSORS
     AstVarScope* varScp() const { return m_varScp; }
-    virtual string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
-    virtual string dotColor() const override {
+    string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
+    string dotColor() const override {
         return fromFlop() ? "green" : cntAsyncRst() ? "red" : "blue";
     }
     int cntAsyncRst() const { return m_cntAsyncRst; }
@@ -118,12 +118,10 @@ public:
         srcDomainp(sensenodep);
         dstDomainp(sensenodep);
     }
-    virtual ~CdcLogicVertex() override = default;
+    ~CdcLogicVertex() override = default;
     // ACCESSORS
-    virtual string name() const override {
-        return (cvtToHex(nodep()) + "@" + scopep()->prettyName());
-    }
-    virtual string dotColor() const override { return hazard() ? "black" : "yellow"; }
+    string name() const override { return (cvtToHex(nodep()) + "@" + scopep()->prettyName()); }
+    string dotColor() const override { return hazard() ? "black" : "yellow"; }
     bool hazard() const { return m_hazard; }
     void setHazard(AstNode* nodep) {
         m_hazard = true;
@@ -144,7 +142,7 @@ private:
     std::ofstream* const m_ofp = nullptr;  // Output file
     string m_prefix;
 
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         *m_ofp << m_prefix;
         if (nodep->user3()) {
             *m_ofp << " %%";
@@ -171,7 +169,7 @@ public:
         , m_prefix{prefix} {
         iterate(nodep);
     }
-    virtual ~CdcDumpVisitor() override = default;
+    ~CdcDumpVisitor() override = default;
 };
 
 //######################################################################
@@ -181,7 +179,7 @@ private:
     int m_maxLineno = 0;
     size_t m_maxFilenameLen = 0;
 
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         // Keeping line+filename lengths separate is much faster than calling ascii().length()
         if (nodep->fileline()->lineno() >= m_maxLineno) {
@@ -195,7 +193,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit CdcWidthVisitor(AstNode* nodep) { iterate(nodep); }
-    virtual ~CdcWidthVisitor() override = default;
+    ~CdcWidthVisitor() override = default;
     // ACCESSORS
     int maxWidth() const {
         size_t width = 1;
@@ -628,21 +626,21 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UINFO(4, " SCOPE " << nodep << endl);
         m_scopep = nodep;
         m_logicVertexp = nullptr;
         iterateChildren(nodep);
         m_scopep = nullptr;
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         // Create required blocks and add to module
         UINFO(4, "  BLOCK  " << nodep << endl);
         AstNode::user2ClearTree();
@@ -654,7 +652,7 @@ private:
         m_domainp = nullptr;
         AstNode::user2ClearTree();
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         if (m_scopep) {
             UASSERT_OBJ(m_logicVertexp, nodep, "Var ref not under a logic block");
             AstVarScope* const varscp = nodep->varScopep();
@@ -682,53 +680,53 @@ private:
             }
         }
     }
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         m_inDly = true;
         iterateChildren(nodep);
         m_inDly = false;
     }
-    virtual void visit(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         m_inSenItem = true;
         iterateChildren(nodep);
         m_inSenItem = false;
     }
-    virtual void visit(AstAlways* nodep) override { iterateNewStmt(nodep); }
-    virtual void visit(AstAlwaysPublic* nodep) override {
+    void visit(AstAlways* nodep) override { iterateNewStmt(nodep); }
+    void visit(AstAlwaysPublic* nodep) override {
         // CDC doesn't care about public variables
     }
-    virtual void visit(AstCFunc* nodep) override { iterateNewStmt(nodep); }
-    virtual void visit(AstAssignAlias* nodep) override { iterateNewStmt(nodep); }
-    virtual void visit(AstAssignW* nodep) override { iterateNewStmt(nodep); }
+    void visit(AstCFunc* nodep) override { iterateNewStmt(nodep); }
+    void visit(AstAssignAlias* nodep) override { iterateNewStmt(nodep); }
+    void visit(AstAssignW* nodep) override { iterateNewStmt(nodep); }
 
     // Math that shouldn't cause us to clear hazard
-    virtual void visit(AstConst*) override {}
-    virtual void visit(AstReplicate* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstConcat* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstNot* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstConst*) override {}
+    void visit(AstReplicate* nodep) override { iterateChildren(nodep); }
+    void visit(AstConcat* nodep) override { iterateChildren(nodep); }
+    void visit(AstNot* nodep) override { iterateChildren(nodep); }
+    void visit(AstSel* nodep) override {
         if (!VN_IS(nodep->lsbp(), Const)) setNodeHazard(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeSel* nodep) override {
+    void visit(AstNodeSel* nodep) override {
         if (!VN_IS(nodep->bitp(), Const)) setNodeHazard(nodep);
         iterateChildren(nodep);
     }
 
     // Ignores
-    virtual void visit(AstInitial*) override {}
-    virtual void visit(AstInitialAutomatic*) override {}
-    virtual void visit(AstInitialStatic*) override {}
-    virtual void visit(AstTraceDecl*) override {}
-    virtual void visit(AstCoverToggle*) override {}
-    virtual void visit(AstNodeDType*) override {}
+    void visit(AstInitial*) override {}
+    void visit(AstInitialAutomatic*) override {}
+    void visit(AstInitialStatic*) override {}
+    void visit(AstTraceDecl*) override {}
+    void visit(AstCoverToggle*) override {}
+    void visit(AstNodeDType*) override {}
 
     //--------------------
     // Default
-    virtual void visit(AstNodeMath* nodep) override {
+    void visit(AstNodeMath* nodep) override {
         setNodeHazard(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -754,7 +752,7 @@ public:
             *m_ofp << '\n';
         }
     }
-    virtual ~CdcVisitor() override {
+    ~CdcVisitor() override {
         if (m_ofp) VL_DO_CLEAR(delete m_ofp, m_ofp = nullptr);
     }
 };

src/V3Changed.cpp

@@ -155,13 +155,13 @@ private:
         m_state.m_numStmts += initp->nodeCount() + m_varEqnp->widthWords();
     }
 
-    virtual void visit(AstBasicDType*) override {  //
+    void visit(AstBasicDType*) override {  //
         newChangeDet();
     }
-    virtual void visit(AstPackArrayDType*) override {  //
+    void visit(AstPackArrayDType*) override {  //
         newChangeDet();
     }
-    virtual void visit(AstUnpackArrayDType* nodep) override {
+    void visit(AstUnpackArrayDType* nodep) override {
         for (int index = 0; index < nodep->elementsConst(); ++index) {
             VL_RESTORER(m_varEqnp);
             VL_RESTORER(m_newLvEqnp);
@@ -181,7 +181,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) override {
+    void visit(AstNodeUOrStructDType* nodep) override {
         if (nodep->packedUnsup()) {
             newChangeDet();
         } else {
@@ -191,7 +191,7 @@ private:
                                               << m_vscp->varp()->prettyNameQ());
         }
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         if (debug()) nodep->dumpTree(cout, "-DETECTARRAY-general-");
         m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable"
@@ -231,7 +231,7 @@ public:
         m_newLvEqnp->deleteTree();
         m_newRvEqnp->deleteTree();
     }
-    virtual ~ChangedInsertVisitor() override = default;
+    ~ChangedInsertVisitor() override = default;
     VL_UNCOPYABLE(ChangedInsertVisitor);
 };
 

src/V3Class.cpp

@@ -49,7 +49,7 @@ private:
     // METHODS
     VL_DEBUG_FUNC;  // Declare debug()
 
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         if (nodep->user1SetOnce()) return;
         // Move this class
         nodep->name(m_prefix + nodep->name());
@@ -100,7 +100,7 @@ private:
         }
         nodep->repairCache();
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // Visit for NodeModules that are not AstClass (AstClass is-a AstNodeModule)
         VL_RESTORER(m_prefix);
         {
@@ -109,7 +109,7 @@ private:
         }
     }
 
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         iterateChildren(nodep);
         if (m_packageScopep) {
             if (m_ftaskp && m_ftaskp->lifetime().isStatic()) {
@@ -127,12 +127,12 @@ private:
         }
     }
 
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         iterateChildren(nodep);
         nodep->varp()->user1p(nodep);
     }
 
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         VL_RESTORER(m_ftaskp);
         {
             m_ftaskp = nodep;
@@ -142,7 +142,7 @@ private:
             }
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         iterateChildren(nodep);
         // Don't move now, or wouldn't keep interating the class
         // TODO move function statics only
@@ -150,14 +150,14 @@ private:
         //    m_toScopeMoves.push_back(std::make_pair(nodep, m_classScopep));
         //}
     }
-    virtual void visit(AstInitial* nodep) override {
+    void visit(AstInitial* nodep) override {
         // But not AstInitialAutomatic, which remains under the class
         iterateChildren(nodep);
         if (m_packageScopep) {
             m_toScopeMoves.emplace_back(std::make_pair(nodep, m_packageScopep));
         }
     }
-    virtual void visit(AstInitialStatic* nodep) override {
+    void visit(AstInitialStatic* nodep) override {
         // But not AstInitialAutomatic, which remains under the class
         iterateChildren(nodep);
         if (m_packageScopep) {
@@ -165,14 +165,14 @@ private:
         }
     }
 
-    virtual void visit(AstNodeMath* nodep) override {}  // Short circuit
-    virtual void visit(AstNodeStmt* nodep) override {}  // Short circuit
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath* nodep) override {}  // Short circuit
+    void visit(AstNodeStmt* nodep) override {}  // Short circuit
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit ClassVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~ClassVisitor() override {
+    ~ClassVisitor() override {
         for (auto moved : m_toScopeMoves) {
             AstNode* const nodep = moved.first;
             AstScope* const scopep = moved.second;

src/V3Clean.cpp

@@ -173,64 +173,64 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeUniop* nodep) override {
+    void visit(AstNodeUniop* nodep) override {
         iterateChildren(nodep);
         computeCppWidth(nodep);
         if (nodep->cleanLhs()) ensureClean(nodep->lhsp());
         setClean(nodep, nodep->cleanOut());
     }
-    virtual void visit(AstNodeBiop* nodep) override {
+    void visit(AstNodeBiop* nodep) override {
         operandBiop(nodep);
         setClean(nodep, nodep->cleanOut());
     }
-    virtual void visit(AstAnd* nodep) override {
+    void visit(AstAnd* nodep) override {
         operandBiop(nodep);
         setClean(nodep, isClean(nodep->lhsp()) || isClean(nodep->rhsp()));
     }
-    virtual void visit(AstXor* nodep) override {
+    void visit(AstXor* nodep) override {
         operandBiop(nodep);
         setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
-    virtual void visit(AstOr* nodep) override {
+    void visit(AstOr* nodep) override {
         operandBiop(nodep);
         setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
-    virtual void visit(AstNodeQuadop* nodep) override {
+    void visit(AstNodeQuadop* nodep) override {
         operandQuadop(nodep);
         setClean(nodep, nodep->cleanOut());
     }
-    virtual void visit(AstNodeMath* nodep) override {
+    void visit(AstNodeMath* nodep) override {
         iterateChildren(nodep);
         computeCppWidth(nodep);
         setClean(nodep, nodep->cleanOut());
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         iterateChildren(nodep);
         computeCppWidth(nodep);
         if (nodep->cleanRhs()) ensureClean(nodep->rhsp());
     }
-    virtual void visit(AstText* nodep) override {  //
+    void visit(AstText* nodep) override {  //
         setClean(nodep, true);
     }
-    virtual void visit(AstScopeName* nodep) override {  //
+    void visit(AstScopeName* nodep) override {  //
         setClean(nodep, true);
     }
-    virtual void visit(AstCNew* nodep) override {
+    void visit(AstCNew* nodep) override {
         iterateChildren(nodep);
         setClean(nodep, true);
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         operandTriop(nodep);
         setClean(nodep, nodep->cleanOut());
     }
-    virtual void visit(AstUCFunc* nodep) override {
+    void visit(AstUCFunc* nodep) override {
         iterateChildren(nodep);
         computeCppWidth(nodep);
         setClean(nodep, false);
@@ -238,69 +238,69 @@ private:
         if (!VN_IS(nodep->backp(), And)) insertClean(nodep);
         ensureCleanAndNext(nodep->bodysp());
     }
-    virtual void visit(AstTraceDecl* nodep) override {
+    void visit(AstTraceDecl* nodep) override {
         // No cleaning, or would loose pointer to enum
         iterateChildren(nodep);
     }
-    virtual void visit(AstTraceInc* nodep) override {
+    void visit(AstTraceInc* nodep) override {
         iterateChildren(nodep);
         ensureCleanAndNext(nodep->valuep());
     }
-    virtual void visit(AstTypedef* nodep) override {
+    void visit(AstTypedef* nodep) override {
         // No cleaning, or would loose pointer to enum
         iterateChildren(nodep);
     }
-    virtual void visit(AstParamTypeDType* nodep) override {
+    void visit(AstParamTypeDType* nodep) override {
         // No cleaning, or would loose pointer to enum
         iterateChildren(nodep);
     }
 
     // Control flow operators
-    virtual void visit(AstNodeCond* nodep) override {
+    void visit(AstNodeCond* nodep) override {
         iterateChildren(nodep);
         ensureClean(nodep->condp());
         setClean(nodep, isClean(nodep->expr1p()) && isClean(nodep->expr2p()));
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         iterateChildren(nodep);
         ensureClean(nodep->condp());
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         iterateChildren(nodep);
         ensureClean(nodep->condp());
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         iterateChildren(nodep);
         ensureCleanAndNext(nodep->exprsp());
         setClean(nodep, true);  // generates a string, so not relevant
     }
-    virtual void visit(AstUCStmt* nodep) override {
+    void visit(AstUCStmt* nodep) override {
         iterateChildren(nodep);
         ensureCleanAndNext(nodep->bodysp());
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         iterateChildren(nodep);
         ensureCleanAndNext(nodep->argsp());
         setClean(nodep, true);
     }
-    virtual void visit(AstCMethodHard* nodep) override {
+    void visit(AstCMethodHard* nodep) override {
         iterateChildren(nodep);
         ensureCleanAndNext(nodep->pinsp());
         setClean(nodep, true);
     }
-    virtual void visit(AstWith* nodep) override {
+    void visit(AstWith* nodep) override {
         iterateChildren(nodep);
         ensureCleanAndNext(nodep->exprp());
         setClean(nodep, true);
     }
-    virtual void visit(AstIntfRef* nodep) override {
+    void visit(AstIntfRef* nodep) override {
         iterateChildren(nodep);
         setClean(nodep, true);  // generates a string, so not relevant
     }
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         computeCppWidth(nodep);
     }
@@ -308,7 +308,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit CleanVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~CleanVisitor() override = default;
+    ~CleanVisitor() override = default;
 };
 
 //######################################################################

src/V3Clock.cpp

@@ -242,7 +242,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep) override {
+    void visit(AstTopScope* nodep) override {
         UINFO(4, " TOPSCOPE   " << nodep << endl);
         m_topScopep = nodep;
         m_scopep = nodep->scopep();
@@ -277,7 +277,7 @@ private:
         m_topScopep = nullptr;
         m_scopep = nullptr;
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // UINFO(4, " MOD   " << nodep << endl);
         VL_RESTORER(m_modp);
         {
@@ -285,7 +285,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         // UINFO(4, " SCOPE   " << nodep << endl);
         m_scopep = nodep;
         iterateChildren(nodep);
@@ -296,14 +296,14 @@ private:
         }
         m_scopep = nullptr;
     }
-    virtual void visit(AstNodeProcedure* nodep) override {
+    void visit(AstNodeProcedure* nodep) override {
         if (AstNode* const stmtsp = nodep->bodysp()) {
             stmtsp->unlinkFrBackWithNext();
             nodep->addNextHere(stmtsp);
         }
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstCoverToggle* nodep) override {
+    void visit(AstCoverToggle* nodep) override {
         // nodep->dumpTree(cout, "ct:");
         // COVERTOGGLE(INC, ORIG, CHANGE) ->
         //   IF(ORIG ^ CHANGE) { INC; CHANGE = ORIG; }
@@ -320,7 +320,7 @@ private:
         nodep->replaceWith(newp);
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         iterateChildren(nodep);
         // Link to global function
         if (nodep->isFinal()) {
@@ -329,7 +329,7 @@ private:
             m_finalFuncp->addStmtsp(callp);
         }
     }
-    virtual void visit(AstSenTree* nodep) override {
+    void visit(AstSenTree* nodep) override {
         // Delete it later; Actives still pointing to it
         nodep->unlinkFrBack();
         pushDeletep(nodep);
@@ -343,7 +343,7 @@ private:
     void addToInitial(AstNode* stmtsp) {
         m_initFuncp->addStmtsp(stmtsp);  // add to top level function
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         // 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()) {
@@ -411,7 +411,7 @@ private:
             VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
         }
     }
-    virtual void visit(AstExecGraph* nodep) override {
+    void visit(AstExecGraph* nodep) override {
         VL_RESTORER(m_mtaskBodyp);
         for (m_mtaskBodyp = nodep->mTaskBodiesp(); m_mtaskBodyp;
              m_mtaskBodyp = VN_AS(m_mtaskBodyp->nextp(), MTaskBody)) {
@@ -427,7 +427,7 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -437,7 +437,7 @@ public:
         // easily without iterating through the tree.
         nodep->evalp(m_evalFuncp);
     }
-    virtual ~ClockVisitor() override = default;
+    ~ClockVisitor() override = default;
 };
 
 //######################################################################

src/V3Combine.cpp

@@ -180,32 +180,32 @@ class CombineVisitor final : VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Gather functions and references
         iterateChildrenConst(nodep);
         // Combine functions
         process(nodep);
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         UASSERT_OBJ(!m_modp, nodep, "Should not nest");
         m_modp = nodep;
         iterateChildrenConst(nodep);
         m_modp = nullptr;
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         iterateChildrenConst(nodep);
         if (nodep->dontCombine()) return;
         auto& coll = nodep->slow() ? m_cfuncs(m_modp).m_slow : m_cfuncs(m_modp).m_fast;
         coll.emplace_back(nodep);
     }
-    virtual void visit(AstCCall* nodep) override {
+    void visit(AstCCall* nodep) override {
         iterateChildrenConst(nodep);
         AstCFunc* const funcp = nodep->funcp();
         if (funcp->dontCombine()) return;
         m_callSites(funcp).emplace_back(nodep);
     }
 
-    virtual void visit(AstAddrOfCFunc* nodep) override {
+    void visit(AstAddrOfCFunc* nodep) override {
         iterateChildrenConst(nodep);
         if (nodep->funcp()->dontCombine()) return;
         // LCOV_EXCL_START
@@ -217,7 +217,7 @@ class CombineVisitor final : VNVisitor {
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
+    void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
 
     // CONSTRUCTORS
     explicit CombineVisitor(AstNetlist* nodep) { iterate(nodep); }

src/V3Const.cpp

@@ -417,14 +417,12 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNode* nodep) override {
-        CONST_BITOP_SET_FAILED("Hit unexpected op", nodep);
-    }
-    virtual void visit(AstCCast* nodep) override {
+    void visit(AstNode* nodep) override { CONST_BITOP_SET_FAILED("Hit unexpected op", nodep); }
+    void visit(AstCCast* nodep) override {
         iterateChildren(nodep);
         if (m_leafp) m_leafp->updateBitRange(nodep);
     }
-    virtual void visit(AstShiftR* nodep) override {
+    void visit(AstShiftR* nodep) override {
         CONST_BITOP_RETURN_IF(!m_leafp, nodep);
         AstConst* const constp = VN_CAST(nodep->rhsp(), Const);
         CONST_BITOP_RETURN_IF(!constp, nodep->rhsp());
@@ -434,7 +432,7 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
         m_leafp->updateBitRange(nodep);
         m_lsb -= constp->toUInt();
     }
-    virtual void visit(AstNot* nodep) override {
+    void visit(AstNot* nodep) override {
         CONST_BITOP_RETURN_IF(nodep->widthMin() != 1, nodep);
         AstNode* lhsp = nodep->lhsp();
         AstCCast* const castp = VN_CAST(lhsp, CCast);
@@ -449,7 +447,7 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
         if (!isXorTree()) m_polarity = !m_polarity;
         if (m_leafp && castp) m_leafp->updateBitRange(castp);
     }
-    virtual void visit(AstWordSel* nodep) override {
+    void visit(AstWordSel* nodep) override {
         CONST_BITOP_RETURN_IF(!m_leafp, nodep);
         AstConst* const constp = VN_CAST(nodep->bitp(), Const);
         CONST_BITOP_RETURN_IF(!constp, nodep->rhsp());
@@ -457,17 +455,17 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
         m_leafp->wordIdx(constp->toSInt());
         iterate(nodep->fromp());
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         CONST_BITOP_RETURN_IF(!m_leafp, nodep);
         m_leafp->setLeaf(nodep);
         m_leafp->polarity(m_polarity);
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         CONST_BITOP_RETURN_IF(!m_leafp, nodep);
         m_leafp->setLeaf(nodep);
     }
 
-    virtual void visit(AstRedXor* nodep) override {
+    void visit(AstRedXor* nodep) override {
         Restorer restorer{*this};
         CONST_BITOP_RETURN_IF(!VN_IS(m_rootp, Xor), nodep);
         AstNode* lhsp = nodep->lhsp();
@@ -514,7 +512,7 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
         }
     }
 
-    virtual void visit(AstNodeBiop* nodep) override {
+    void visit(AstNodeBiop* nodep) override {
         if (VN_IS(nodep, And) && isConst(nodep->lhsp(), 1)) {  // 1 & _
             // Always reach past a plain making AND
             Restorer restorer{*this};
@@ -2252,11 +2250,11 @@ private:
     //----------------------------------------
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Iterate modules backwards, in bottom-up order.  That's faster
         iterateChildrenBackwards(nodep);
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
@@ -2264,7 +2262,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         // No ASSIGNW removals under funcs, we've long eliminated INITIALs
         // (We should perhaps rename the assignw's to just assigns)
         VL_RESTORER(m_wremove);
@@ -2273,7 +2271,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         // No ASSIGNW removals under scope, we've long eliminated INITIALs
         VL_RESTORER(m_wremove);
         VL_RESTORER(m_scopep);
@@ -2370,17 +2368,17 @@ private:
     }
 
     // Special cases
-    virtual void visit(AstConst*) override {}  // Already constant
+    void visit(AstConst*) override {}  // Already constant
 
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         if (m_params) {
             iterateAndNextNull(nodep->paramsp());
         } else {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstClassOrPackageRef* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstPin* nodep) override { iterateChildren(nodep); }
+    void visit(AstClassOrPackageRef* nodep) override { iterateChildren(nodep); }
+    void visit(AstPin* nodep) override { iterateChildren(nodep); }
 
     void replaceLogEq(AstLogEq* nodep) {
         // LOGEQ(a,b) => AstLogAnd{AstLogOr{AstLogNot{a},b},AstLogOr{AstLogNot{b},a}}
@@ -2562,7 +2560,7 @@ private:
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
 
-    virtual void visit(AstAttrOf* nodep) override {
+    void visit(AstAttrOf* nodep) override {
         VL_RESTORER(m_attrp);
         {
             m_attrp = nodep;
@@ -2570,7 +2568,7 @@ private:
         }
     }
 
-    virtual void visit(AstArraySel* nodep) override {
+    void visit(AstArraySel* nodep) override {
         iterateAndNextNull(nodep->bitp());
         if (VN_IS(nodep->bitp(), Const)
             && VN_IS(nodep->fromp(), VarRef)
@@ -2596,7 +2594,7 @@ private:
         }
         m_selp = nullptr;
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         iterateChildren(nodep);
         UASSERT_OBJ(nodep->varp(), nodep, "Not linked");
         bool did = false;
@@ -2650,7 +2648,7 @@ private:
                            << nodep->varp()->prettyNameQ());
         }
     }
-    virtual void visit(AstEnumItemRef* nodep) override {
+    void visit(AstEnumItemRef* nodep) override {
         iterateChildren(nodep);
         UASSERT_OBJ(nodep->itemp(), nodep, "Not linked");
         bool did = false;
@@ -2675,7 +2673,7 @@ private:
         }
     }
 
-    // virtual void visit(AstCvtPackString* nodep) override {
+    //  void visit(AstCvtPackString* nodep) override {
     // Not constant propagated (for today) because AstNodeMath::isOpaque is set
     // Someday if lower is constant, convert to quoted "string".
 
@@ -2683,7 +2681,7 @@ private:
         // Only one if it's not in a list
         return (!nodep->nextp() && nodep->backp()->nextp() != nodep);
     }
-    virtual void visit(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         iterateChildren(nodep);
         if (m_doNConst
             && (VN_IS(nodep->sensp(), Const) || VN_IS(nodep->sensp(), EnumItemRef)
@@ -2750,7 +2748,7 @@ private:
         }
     };
 
-    virtual void visit(AstSenTree* nodep) override {
+    void visit(AstSenTree* nodep) override {
         iterateChildren(nodep);
         if (m_doExpensive) {
             // cout<<endl; nodep->dumpTree(cout, "ssin: ");
@@ -2834,17 +2832,17 @@ private:
 
     //-----
     // Zero elimination
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         iterateChildren(nodep);
         if (m_doNConst && replaceNodeAssign(nodep)) return;
     }
-    virtual void visit(AstAssignAlias* nodep) override {
+    void visit(AstAssignAlias* nodep) override {
         // Don't perform any optimizations, keep the alias around
     }
-    virtual void visit(AstAssignVarScope* nodep) override {
+    void visit(AstAssignVarScope* nodep) override {
         // Don't perform any optimizations, the node won't be linked yet
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         iterateChildren(nodep);
         if (m_doNConst && replaceNodeAssign(nodep)) return;
         AstNodeVarRef* const varrefp = VN_CAST(
@@ -2871,7 +2869,7 @@ private:
             varrefp->varp()->valuep(initvaluep);
         }
     }
-    virtual void visit(AstRelease* nodep) override {
+    void visit(AstRelease* nodep) override {
         if (AstConcat* const concatp = VN_CAST(nodep->lhsp(), Concat)) {
             FileLine* const flp = nodep->fileline();
             AstRelease* const newLp = new AstRelease{flp, concatp->lhsp()->unlinkFrBack()};
@@ -2884,7 +2882,7 @@ private:
         }
     }
 
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         iterateChildren(nodep);
         if (m_doNConst) {
             if (const AstConst* const constp = VN_CAST(nodep->condp(), Const)) {
@@ -2968,7 +2966,7 @@ private:
         }
     }
 
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisplay* nodep) override {
         // DISPLAY(SFORMAT(text1)),DISPLAY(SFORMAT(text2)) -> DISPLAY(SFORMAT(text1+text2))
         iterateChildren(nodep);
         if (stmtDisplayDisplay(nodep)) return;
@@ -3022,7 +3020,7 @@ private:
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
         return true;
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         // 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.
@@ -3089,17 +3087,17 @@ private:
         }
     }
 
-    virtual void visit(AstFuncRef* nodep) override {
+    void visit(AstFuncRef* nodep) override {
         iterateChildren(nodep);
         if (m_params) {  // Only parameters force us to do constant function call propagation
             replaceWithSimulation(nodep);
         }
     }
-    virtual void visit(AstArg* nodep) override {
+    void visit(AstArg* nodep) override {
         // replaceWithSimulation on the Arg's parent FuncRef replaces these
         iterateChildren(nodep);
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         const bool oldHasJumpDelay = m_hasJumpDelay;
         m_hasJumpDelay = false;
         { iterateChildren(nodep); }
@@ -3125,22 +3123,22 @@ private:
             }
         }
     }
-    virtual void visit(AstInitArray* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstUnbounded* nodep) override { iterateChildren(nodep); }
+    void visit(AstInitArray* nodep) override { iterateChildren(nodep); }
+    void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
+    void visit(AstUnbounded* nodep) override { iterateChildren(nodep); }
     // 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*) override {}
+    void visit(AstNodePreSel*) override {}
 
     // Ignored, can eliminate early
-    virtual void visit(AstSysIgnore* nodep) override {
+    void visit(AstSysIgnore* nodep) override {
         iterateChildren(nodep);
         if (m_doNConst) VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
 
     // Simplify
-    virtual void visit(AstBasicDType* nodep) override {
+    void visit(AstBasicDType* nodep) override {
         iterateChildren(nodep);
         nodep->cvtRangeConst();
     }
@@ -3148,11 +3146,11 @@ private:
     //-----
     // Jump elimination
 
-    virtual void visit(AstDelay* nodep) override {
+    void visit(AstDelay* nodep) override {
         iterateChildren(nodep);
         m_hasJumpDelay = true;
     }
-    virtual void visit(AstJumpGo* nodep) override {
+    void visit(AstJumpGo* nodep) override {
         iterateChildren(nodep);
         // Jump to label where label immediately follows label is not useful
         if (nodep->labelp() == VN_CAST(nodep->nextp(), JumpLabel)) {
@@ -3183,7 +3181,7 @@ private:
         m_hasJumpDelay = true;
     }
 
-    virtual void visit(AstJumpBlock* nodep) override {
+    void visit(AstJumpBlock* nodep) override {
         // 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
@@ -3537,7 +3535,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) override {
+    void visit(AstNode* nodep) override {
         // Default: Just iterate
         if (m_required) {
             if (VN_IS(nodep, NodeDType) || VN_IS(nodep, Range) || VN_IS(nodep, SliceSel)) {
@@ -3584,7 +3582,7 @@ public:
         }
         // clang-format on
     }
-    virtual ~ConstVisitor() override {
+    ~ConstVisitor() override {
         if (m_doCpp) {
             if (m_globalPass) {
                 V3Stats::addStat("Optimizations, Const bit op reduction", m_statBitOpReduction);

src/V3Coverage.cpp

@@ -209,7 +209,7 @@ private:
     }
 
     // VISITORS - BOTH
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         const AstNodeModule* const origModp = m_modp;
         VL_RESTORER(m_modp);
         VL_RESTORER(m_state);
@@ -227,9 +227,9 @@ private:
         }
     }
 
-    virtual void visit(AstNodeProcedure* nodep) override { iterateProcedure(nodep); }
-    virtual void visit(AstWhile* nodep) override { iterateProcedure(nodep); }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeProcedure* nodep) override { iterateProcedure(nodep); }
+    void visit(AstWhile* nodep) override { iterateProcedure(nodep); }
+    void visit(AstNodeFTask* nodep) override {
         if (!nodep->dpiImport()) iterateProcedure(nodep);
     }
     void iterateProcedure(AstNode* nodep) {
@@ -258,7 +258,7 @@ private:
     }
 
     // VISITORS - TOGGLE COVERAGE
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         iterateChildren(nodep);
         if (m_modp && !m_inToggleOff && !m_state.m_inModOff && nodep->fileline()->coverageOn()
             && v3Global.opt.coverageToggle()) {
@@ -383,7 +383,7 @@ private:
 
     // VISITORS - LINE COVERAGE
     // Note not AstNodeIf; other types don't get covered
-    virtual void visit(AstIf* nodep) override {
+    void visit(AstIf* nodep) override {
         UINFO(4, " IF: " << nodep << endl);
         if (m_state.m_on) {
             // An else-if.  When we iterate the if, use "elsif" marking
@@ -460,7 +460,7 @@ private:
         }
         UINFO(9, " done HANDLE " << m_state.m_handle << " for " << nodep << endl);
     }
-    virtual void visit(AstCaseItem* nodep) override {
+    void visit(AstCaseItem* nodep) override {
         // We don't add an explicit "default" coverage if not provided,
         // as we already have a warning when there is no default.
         UINFO(4, " CASEI: " << nodep << endl);
@@ -479,7 +479,7 @@ private:
             }
         }
     }
-    virtual void visit(AstCover* nodep) override {
+    void visit(AstCover* nodep) override {
         UINFO(4, " COVER: " << nodep << endl);
         VL_RESTORER(m_state);
         {
@@ -495,11 +495,11 @@ private:
             }
         }
     }
-    virtual void visit(AstStop* nodep) override {
+    void visit(AstStop* nodep) override {
         UINFO(4, "  STOP: " << nodep << endl);
         m_state.m_on = false;
     }
-    virtual void visit(AstPragma* nodep) override {
+    void visit(AstPragma* nodep) override {
         if (nodep->pragType() == VPragmaType::COVERAGE_BLOCK_OFF) {
             // Skip all NEXT nodes under this block, and skip this if/case branch
             UINFO(4, "  OFF: h" << m_state.m_handle << " " << nodep << endl);
@@ -510,7 +510,7 @@ private:
             lineTrack(nodep);
         }
     }
-    virtual void visit(AstBegin* nodep) override {
+    void visit(AstBegin* nodep) override {
         // 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.
@@ -529,7 +529,7 @@ private:
     }
 
     // VISITORS - BOTH
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         lineTrack(nodep);
     }
@@ -537,7 +537,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit CoverageVisitor(AstNetlist* rootp) { iterateChildren(rootp); }
-    virtual ~CoverageVisitor() override = default;
+    ~CoverageVisitor() override = default;
 };
 
 //######################################################################

src/V3CoverageJoin.cpp

@@ -88,24 +88,24 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Find all Coverage's
         iterateChildren(nodep);
         // Simplify
         detectDuplicates();
     }
-    virtual void visit(AstCoverToggle* nodep) override {
+    void visit(AstCoverToggle* nodep) override {
         m_toggleps.push_back(nodep);
         iterateChildren(nodep);
     }
     //--------------------
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit CoverageJoinVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~CoverageJoinVisitor() override {
+    ~CoverageJoinVisitor() override {
         V3Stats::addStat("Coverage, Toggle points joined", m_statToggleJoins);
     }
 };

src/V3Dead.cpp

@@ -102,7 +102,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         if (m_modp) m_modp->user1Inc();  // e.g. Class under Package
         VL_RESTORER(m_modp);
         {
@@ -120,12 +120,12 @@ private:
             }
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
         if (nodep->scopep()) nodep->scopep()->user1Inc();
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
         if (nodep->aboveScopep()) nodep->aboveScopep()->user1Inc();
@@ -136,14 +136,14 @@ private:
             m_scopesp.push_back(nodep);
         }
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
         m_cellsp.push_back(nodep);
         nodep->modp()->user1Inc();
     }
 
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         // Note NodeAssign skips calling this in some cases
         iterateChildren(nodep);
         checkAll(nodep);
@@ -155,7 +155,7 @@ private:
         if (nodep->varp()) nodep->varp()->user1Inc();
         if (nodep->classOrPackagep()) nodep->classOrPackagep()->user1Inc();
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
         if (nodep->classOrPackagep()) {
@@ -166,11 +166,11 @@ private:
             }
         }
     }
-    virtual void visit(AstMethodCall* nodep) override {
+    void visit(AstMethodCall* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
     }
-    virtual void visit(AstRefDType* nodep) override {
+    void visit(AstRefDType* nodep) override {
         iterateChildren(nodep);
         checkDType(nodep);
         checkAll(nodep);
@@ -184,7 +184,7 @@ private:
             }
         }
     }
-    virtual void visit(AstClassRefDType* nodep) override {
+    void visit(AstClassRefDType* nodep) override {
         iterateChildren(nodep);
         checkDType(nodep);
         checkAll(nodep);
@@ -197,12 +197,12 @@ private:
         }
         if (nodep->classp()) nodep->classp()->user1Inc();
     }
-    virtual void visit(AstNodeDType* nodep) override {
+    void visit(AstNodeDType* nodep) override {
         iterateChildren(nodep);
         checkDType(nodep);
         checkAll(nodep);
     }
-    virtual void visit(AstEnumItemRef* nodep) override {
+    void visit(AstEnumItemRef* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
         if (nodep->classOrPackagep()) {
@@ -214,13 +214,13 @@ private:
         }
         checkAll(nodep);
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         iterateChildren(nodep);
         if (nodep->varp()) nodep->varp()->user1Inc();
         if (nodep->fromp()->dtypep()) nodep->fromp()->dtypep()->user1Inc();  // classref
         checkAll(nodep);
     }
-    virtual void visit(AstModport* nodep) override {
+    void visit(AstModport* nodep) override {
         iterateChildren(nodep);
         if (m_elimCells) {
             if (!nodep->varsp()) {
@@ -230,14 +230,14 @@ private:
         }
         checkAll(nodep);
     }
-    virtual void visit(AstSelLoopVars* nodep) override {
+    void visit(AstSelLoopVars* nodep) override {
         // Var under a SelLoopVars means we haven't called V3Width to remove them yet
         VL_RESTORER(m_selloopvarsp);
         m_selloopvarsp = nodep;
         iterateChildren(nodep);
         checkAll(nodep);
     }
-    virtual void visit(AstTypedef* nodep) override {
+    void visit(AstTypedef* nodep) override {
         iterateChildren(nodep);
         if (m_elimCells && !nodep->attrPublic()) {
             VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
@@ -248,20 +248,20 @@ private:
         // Normal modules may disappear, e.g. if they are parameterized then removed
         if (nodep->attrPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
     }
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
         if (nodep->scopep()) nodep->scopep()->user1Inc();
         if (mightElimVar(nodep->varp())) m_vscsp.push_back(nodep);
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         iterateChildren(nodep);
         checkAll(nodep);
         if (nodep->isSigPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
         if (m_selloopvarsp) nodep->user1Inc();
         if (mightElimVar(nodep)) m_varsp.push_back(nodep);
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         // See if simple assignments to variables may be eliminated because
         // that variable is never used.
         // Similar code in V3Life
@@ -284,7 +284,7 @@ private:
     }
 
     //-----
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         if (nodep->isOutputter()) m_sideEffect = true;
         iterateChildren(nodep);
         checkAll(nodep);
@@ -446,7 +446,7 @@ public:
         // We may have removed some datatypes, cleanup
         nodep->typeTablep()->repairCache();
     }
-    virtual ~DeadVisitor() override = default;
+    ~DeadVisitor() override = default;
 };
 
 //######################################################################

src/V3Delayed.cpp

@@ -365,24 +365,24 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // VV*****  We reset all userp() on the netlist
         m_modVarMap.clear();
         iterateChildren(nodep);
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UINFO(4, " MOD   " << nodep << endl);
         AstNode::user3ClearTree();
         iterateChildren(nodep);
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         VL_RESTORER(m_cfuncp);
         {
             m_cfuncp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         m_activep = nodep;
         VL_RESTORER(m_inInitial);
         {
@@ -392,7 +392,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         m_inDly = true;
         m_nextDlyp
             = VN_CAST(nodep->nextp(), AssignDly);  // Next assignment in same block, maybe nullptr.
@@ -426,7 +426,7 @@ private:
         m_nextDlyp = nullptr;
     }
 
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (!nodep->user2Inc()) {  // Not done yet
             if (m_inDly && nodep->access().isWriteOrRW()) {
                 UINFO(4, "AssignDlyVar: " << nodep << endl);
@@ -488,18 +488,18 @@ private:
         }
     }
 
-    virtual void visit(AstNodeReadWriteMem* nodep) override {
+    void visit(AstNodeReadWriteMem* nodep) override {
         VL_RESTORER(m_ignoreBlkAndNBlk);
         m_ignoreBlkAndNBlk = true;  // $readmem/$writemem often used in mem models
         // so we will suppress BLKANDNBLK warnings
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstNodeFor* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstNodeFor* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc(
             "For statements should have been converted to while statements in V3Begin");
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         VL_RESTORER(m_inLoop);
         {
             m_inLoop = true;
@@ -508,12 +508,12 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit DelayedVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~DelayedVisitor() override {
+    ~DelayedVisitor() override {
         V3Stats::addStat("Optimizations, Delayed shared-sets", m_statSharedSet);
     }
 };

src/V3Depth.cpp

@@ -73,7 +73,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         VL_RESTORER(m_cfuncp);
         VL_RESTORER(m_mtaskbodyp);
         {
@@ -85,7 +85,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstMTaskBody* nodep) override {
+    void visit(AstMTaskBody* nodep) override {
         VL_RESTORER(m_cfuncp);
         VL_RESTORER(m_mtaskbodyp);
         {
@@ -106,7 +106,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (!nodep->isStatement()) {
             iterateChildren(nodep);
         } else {
@@ -114,8 +114,8 @@ private:
         }
     }
     // Operators
-    virtual void visit(AstNodeTermop* nodep) override {}
-    virtual void visit(AstNodeMath* nodep) override {
+    void visit(AstNodeTermop* nodep) override {}
+    void visit(AstNodeMath* nodep) override {
         // We have some operator defines that use 2 parens, so += 2.
         {
             VL_RESTORER(m_depth);
@@ -142,19 +142,19 @@ private:
             m_cfuncp->isStatic(false);
         }
     }
-    virtual void visit(AstUCFunc* nodep) override {
+    void visit(AstUCFunc* nodep) override {
         needNonStaticFunc(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstUCStmt* nodep) override {
+    void visit(AstUCStmt* nodep) override {
         needNonStaticFunc(nodep);
         visitStmt(nodep);
     }
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar*) override {}  // Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't hit varrefs under vars
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -162,7 +162,7 @@ public:
         : m_tempNames{"__Vdeeptemp"} {
         iterate(nodep);
     }
-    virtual ~DepthVisitor() override = default;
+    ~DepthVisitor() override = default;
 };
 
 //######################################################################

src/V3DepthBlock.cpp

@@ -71,7 +71,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         UINFO(4, " MOD   " << nodep << endl);
         VL_RESTORER(m_modp);
         {
@@ -80,7 +80,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         // We recurse into this.
         VL_RESTORER(m_depth);
         VL_RESTORER(m_cfuncp);
@@ -106,7 +106,7 @@ private:
         }
         m_depth--;
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (!nodep->isStatement()) {
             iterateChildren(nodep);
         } else {
@@ -114,15 +114,15 @@ private:
         }
     }
 
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNodeMath*) override {}  // Accelerate
     //--------------------
-    virtual void visit(AstVar*) override {}  // Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't hit varrefs under vars
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit DepthBlockVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~DepthBlockVisitor() override = default;
+    ~DepthBlockVisitor() override = default;
 };
 
 //######################################################################

src/V3Descope.cpp

@@ -185,11 +185,11 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         nodep->dpiExportTriggerp(nullptr);
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
@@ -199,17 +199,17 @@ private:
             makePublicFuncWrappers();
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         m_scopep = nodep;
         iterateChildren(nodep);
         m_scopep = nullptr;
     }
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         // Delete the varscope when we're finished
         nodep->unlinkFrBack();
         pushDeletep(nodep);
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         iterateChildren(nodep);
         if (!nodep->varScopep()) {
             UASSERT_OBJ(nodep->varp()->isFuncLocal(), nodep,
@@ -233,7 +233,7 @@ private:
         nodep->varScopep(nullptr);
         UINFO(9, "  refout " << nodep << " selfPtr=" << nodep->selfPointer() << endl);
     }
-    virtual void visit(AstCCall* nodep) override {
+    void visit(AstCCall* nodep) override {
         // UINFO(9, "       " << nodep << endl);
         iterateChildren(nodep);
         // Convert the hierch name
@@ -243,9 +243,9 @@ private:
         // Can't do this, as we may have more calls later
         // nodep->funcp()->scopep(nullptr);
     }
-    virtual void visit(AstCMethodCall* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstCNew* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCMethodCall* nodep) override { iterateChildren(nodep); }
+    void visit(AstCNew* nodep) override { iterateChildren(nodep); }
+    void visit(AstCFunc* nodep) override {
         VL_RESTORER(m_funcp);
         if (!nodep->user1()) {
             // Static functions should have been moved under the corresponding AstClassPackage
@@ -268,13 +268,13 @@ private:
             }
         }
     }
-    virtual void visit(AstVar*) override {}
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit DescopeVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~DescopeVisitor() override = default;
+    ~DescopeVisitor() override = default;
 };
 
 //######################################################################

src/V3EmitCBase.h

@@ -110,7 +110,7 @@ public:
 
     // CONSTRUCTORS
     EmitCBaseVisitor() = default;
-    virtual ~EmitCBaseVisitor() override = default;
+    ~EmitCBaseVisitor() override = default;
 };
 
 #endif  // guard

src/V3EmitCConstInit.h

@@ -45,7 +45,7 @@ class EmitCConstInit VL_NOT_FINAL : public EmitCBaseVisitor {
 
 protected:
     // VISITORS
-    virtual void visit(AstInitArray* nodep) override {
+    void visit(AstInitArray* nodep) override {
         VL_RESTORER(m_inUnpacked);
         VL_RESTORER(m_unpackedWord);
         m_inUnpacked = true;
@@ -94,11 +94,11 @@ protected:
         }
     }
 
-    virtual void visit(AstInitItem* nodep) override {  // LCOV_EXCL_START
+    void visit(AstInitItem* nodep) override {  // LCOV_EXCL_START
         nodep->v3fatal("Handled by AstInitArray");
     }  // LCOV_EXCL_STOP
 
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         const V3Number& num = nodep->num();
         UASSERT_OBJ(!num.isFourState(), nodep, "4-state value in constant pool");
         const AstNodeDType* const dtypep = nodep->dtypep();
@@ -145,7 +145,7 @@ protected:
     }
 
     // Default
-    virtual void visit(AstNode* nodep) override {  // LCOV_EXCL_START
+    void visit(AstNode* nodep) override {  // LCOV_EXCL_START
         nodep->v3fatalSrc("Unknown node type reached EmitCConstInit: " << nodep->prettyTypeName());
     }  // LCOV_EXCL_STOP
 };

src/V3EmitCConstPool.cpp

@@ -100,7 +100,7 @@ class EmitCConstPool final : public EmitCConstInit {
     }
 
     // VISITORS
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         m_outFileSize += nodep->num().isString() ? 10 : nodep->isWide() ? nodep->widthWords() : 1;
         EmitCConstInit::visit(nodep);
     }

src/V3EmitCFunc.h

@@ -70,17 +70,17 @@ class EmitCLazyDecls final : public VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         lazyDeclare(nodep->funcp());
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstAddrOfCFunc* nodep) override {
+    void visit(AstAddrOfCFunc* nodep) override {
         lazyDeclare(nodep->funcp());
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         AstVar* const varp = nodep->varp();
         // Only constant pool symbols are lazy declared for now ...
         if (EmitCBaseVisitor::isConstPoolMod(EmitCParentModule::get(varp))) {
@@ -88,7 +88,7 @@ class EmitCLazyDecls final : public VNVisitor {
         }
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
+    void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
 
     VL_DEBUG_FUNC;
 
@@ -213,7 +213,7 @@ public:
 
     // VISITORS
     using EmitCConstInit::visit;
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         VL_RESTORER(m_useSelfForThis);
         VL_RESTORER(m_cfuncp);
         m_cfuncp = nodep;
@@ -281,12 +281,12 @@ public:
         if (nodep->ifdef() != "") puts("#endif  // " + nodep->ifdef() + "\n");
     }
 
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         UASSERT_OBJ(m_cfuncp, nodep, "Cannot emit non-local variable");
         emitVarDecl(nodep);
     }
 
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         bool paren = true;
         bool decind = false;
         bool rhs = true;
@@ -368,8 +368,8 @@ public:
         if (decind) ofp()->blockDec();
         puts(";\n");
     }
-    virtual void visit(AstAlwaysPublic*) override {}
-    virtual void visit(AstAssocSel* nodep) override {
+    void visit(AstAlwaysPublic*) override {}
+    void visit(AstAssocSel* nodep) override {
         iterateAndNextNull(nodep->fromp());
         putbs(".at(");
         AstAssocArrayDType* const adtypep = VN_AS(nodep->fromp()->dtypep(), AssocArrayDType);
@@ -381,7 +381,7 @@ public:
         }
         puts(")");
     }
-    virtual void visit(AstWildcardSel* nodep) override {
+    void visit(AstWildcardSel* nodep) override {
         iterateAndNextNull(nodep->fromp());
         putbs(".at(");
         AstWildcardArrayDType* const adtypep = VN_AS(nodep->fromp()->dtypep(), WildcardArrayDType);
@@ -389,7 +389,7 @@ public:
         iterateAndNextNull(nodep->bitp());
         puts(")");
     }
-    virtual void visit(AstCCall* nodep) override {
+    void visit(AstCCall* nodep) override {
         const AstCFunc* const funcp = nodep->funcp();
         const AstNodeModule* const funcModp = EmitCParentModule::get(funcp);
         if (funcp->dpiImportPrototype()) {
@@ -415,7 +415,7 @@ public:
         }
         emitCCallArgs(nodep, nodep->selfPointerProtect(m_useSelfForThis));
     }
-    virtual void visit(AstCMethodCall* nodep) override {
+    void visit(AstCMethodCall* nodep) override {
         const AstCFunc* const funcp = nodep->funcp();
         UASSERT_OBJ(!funcp->isLoose(), nodep, "Loose method called via AstCMethodCall");
         iterate(nodep->fromp());
@@ -423,7 +423,7 @@ public:
         puts(funcp->nameProtect());
         emitCCallArgs(nodep, "");
     }
-    virtual void visit(AstCNew* nodep) override {
+    void visit(AstCNew* nodep) override {
         bool comma = false;
         puts("std::make_shared<" + prefixNameProtect(nodep->dtypep()) + ">(");
         puts("vlSymsp");  // TODO make this part of argsp, and eliminate when unnecessary
@@ -435,7 +435,7 @@ public:
         }
         puts(")");
     }
-    virtual void visit(AstCMethodHard* nodep) override {
+    void visit(AstCMethodHard* nodep) override {
         iterate(nodep->fromp());
         puts(".");
         puts(nodep->name());
@@ -457,8 +457,8 @@ public:
         UASSERT_OBJ(!nodep->isStatement() || VN_IS(nodep->dtypep(), VoidDType), nodep,
                     "Statement of non-void data type");
     }
-    virtual void visit(AstLambdaArgRef* nodep) override { putbs(nodep->nameProtect()); }
-    virtual void visit(AstWith* nodep) override {
+    void visit(AstLambdaArgRef* nodep) override { putbs(nodep->nameProtect()); }
+    void visit(AstWith* nodep) override {
         // With uses a C++11 lambda
         putbs("[=](");
         if (auto* const argrefp = nodep->indexArgRefp()) {
@@ -473,11 +473,11 @@ public:
         iterateAndNextNull(nodep->exprp());
         puts("; }\n");
     }
-    virtual void visit(AstNodeCase* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstNodeCase* nodep) override {  // LCOV_EXCL_LINE
         // In V3Case...
         nodep->v3fatalSrc("Case statements should have been reduced out");
     }
-    virtual void visit(AstComment* nodep) override {
+    void visit(AstComment* nodep) override {
         string at;
         if (nodep->showAt()) {
             at = " at " + nodep->fileline()->ascii();
@@ -489,7 +489,7 @@ public:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstCoverDecl* nodep) override {
+    void visit(AstCoverDecl* nodep) override {
         puts("vlSelf->__vlCoverInsert(");  // As Declared in emitCoverageDecl
         puts("&(vlSymsp->__Vcoverage[");
         puts(cvtToStr(nodep->dataDeclThisp()->binNum()));
@@ -517,7 +517,7 @@ public:
         putsQuoted(nodep->linescov());
         puts(");\n");
     }
-    virtual void visit(AstCoverInc* nodep) override {
+    void visit(AstCoverInc* nodep) override {
         if (v3Global.opt.threads()) {
             puts("vlSymsp->__Vcoverage[");
             puts(cvtToStr(nodep->declp()->dataDeclThisp()->binNum()));
@@ -528,17 +528,17 @@ public:
             puts("]);\n");
         }
     }
-    virtual void visit(AstCReturn* nodep) override {
+    void visit(AstCReturn* nodep) override {
         puts("return (");
         iterateAndNextNull(nodep->lhsp());
         puts(");\n");
     }
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisplay* nodep) override {
         string text = nodep->fmtp()->text();
         if (nodep->addNewline()) text += "\n";
         displayNode(nodep, nodep->fmtp()->scopeNamep(), text, nodep->fmtp()->exprsp(), false);
     }
-    virtual void visit(AstDumpCtl* nodep) override {
+    void visit(AstDumpCtl* nodep) override {
         switch (nodep->ctlType()) {
         case VDumpCtlType::FILE:
             puts("vlSymsp->_vm_contextp__->dumpfile(");
@@ -577,7 +577,7 @@ public:
         default: nodep->v3fatalSrc("Bad case, unexpected " << nodep->ctlType().ascii());
         }
     }
-    virtual void visit(AstScopeName* nodep) override {
+    void visit(AstScopeName* nodep) override {
         // For use under AstCCalls for dpiImports.  ScopeNames under
         // displays are handled in AstDisplay
         if (!nodep->dpiExport()) {
@@ -586,20 +586,20 @@ public:
             putbs("(&(vlSymsp->" + protect("__Vscope_" + scope) + "))");
         }
     }
-    virtual void visit(AstSFormat* nodep) override {
+    void visit(AstSFormat* nodep) override {
         displayNode(nodep, nodep->fmtp()->scopeNamep(), nodep->fmtp()->text(),
                     nodep->fmtp()->exprsp(), false);
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         displayNode(nodep, nodep->scopeNamep(), nodep->text(), nodep->exprsp(), false);
     }
-    virtual void visit(AstFScanF* nodep) override {
+    void visit(AstFScanF* nodep) override {
         displayNode(nodep, nullptr, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstSScanF* nodep) override {
+    void visit(AstSScanF* nodep) override {
         displayNode(nodep, nullptr, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstValuePlusArgs* nodep) override {
+    void visit(AstValuePlusArgs* nodep) override {
         puts("VL_VALUEPLUSARGS_IN");
         emitIQW(nodep->outp());
         puts("(");
@@ -611,19 +611,19 @@ public:
         iterateAndNextNull(nodep->outp());
         puts(")");
     }
-    virtual void visit(AstTestPlusArgs* nodep) override {
+    void visit(AstTestPlusArgs* nodep) override {
         puts("VL_TESTPLUSARGS_I(");
         emitCvtPackStr(nodep->searchp());
         puts(")");
     }
-    virtual void visit(AstFError* nodep) override {
+    void visit(AstFError* nodep) override {
         puts("VL_FERROR_IN(");
         iterateAndNextNull(nodep->filep());
         putbs(", ");
         iterateAndNextNull(nodep->strp());
         puts(")");
     }
-    virtual void visit(AstFGetS* nodep) override {
+    void visit(AstFGetS* nodep) override {
         checkMaxWords(nodep);
         emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nullptr);
     }
@@ -636,7 +636,7 @@ public:
                 << " bits exceeds hardcoded limit VL_VALUE_STRING_MAX_WORDS in verilatedos.h");
         }
     }
-    virtual void visit(AstFOpen* nodep) override {
+    void visit(AstFOpen* nodep) override {
         iterateAndNextNull(nodep->filep());
         puts(" = VL_FOPEN_NN(");
         emitCvtPackStr(nodep->filenamep());
@@ -646,13 +646,13 @@ public:
         emitCvtPackStr(nodep->modep());
         puts(");\n");
     }
-    virtual void visit(AstFOpenMcd* nodep) override {
+    void visit(AstFOpenMcd* nodep) override {
         iterateAndNextNull(nodep->filep());
         puts(" = VL_FOPEN_MCD_N(");
         emitCvtPackStr(nodep->filenamep());
         puts(");\n");
     }
-    virtual void visit(AstNodeReadWriteMem* nodep) override {
+    void visit(AstNodeReadWriteMem* nodep) override {
         puts(nodep->cFuncPrefixp());
         puts("N(");
         puts(nodep->isHex() ? "true" : "false");
@@ -701,14 +701,14 @@ public:
         }
         puts(");\n");
     }
-    virtual void visit(AstFClose* nodep) override {
+    void visit(AstFClose* nodep) override {
         puts("VL_FCLOSE_I(");
         iterateAndNextNull(nodep->filep());
         puts("); ");
         iterateAndNextNull(nodep->filep());  // For safety, so user doesn't later WRITE with it.
         puts(" = 0;\n");
     }
-    virtual void visit(AstFFlush* nodep) override {
+    void visit(AstFFlush* nodep) override {
         if (!nodep->filep()) {
             puts("Verilated::runFlushCallbacks();\n");
         } else {
@@ -719,7 +719,7 @@ public:
             puts("); }\n");
         }
     }
-    virtual void visit(AstFSeek* nodep) override {
+    void visit(AstFSeek* nodep) override {
         puts("(VL_FSEEK_I(");
         iterateAndNextNull(nodep->filep());
         puts(",");
@@ -728,17 +728,17 @@ public:
         iterateAndNextNull(nodep->operation());
         puts(") == -1 ? -1 : 0)");
     }
-    virtual void visit(AstFTell* nodep) override {
+    void visit(AstFTell* nodep) override {
         puts("VL_FTELL_I(");
         iterateAndNextNull(nodep->filep());
         puts(")");
     }
-    virtual void visit(AstFRewind* nodep) override {
+    void visit(AstFRewind* nodep) override {
         puts("(VL_FSEEK_I(");
         iterateAndNextNull(nodep->filep());
         puts(", 0, 0) == -1 ? -1 : 0)");
     }
-    virtual void visit(AstFRead* nodep) override {
+    void visit(AstFRead* nodep) override {
         puts("VL_FREAD_I(");
         puts(cvtToStr(nodep->memp()->widthMin()));  // Need real storage width
         putbs(",");
@@ -781,12 +781,12 @@ public:
         }
         puts(")");
     }
-    virtual void visit(AstSysFuncAsTask* nodep) override {
+    void visit(AstSysFuncAsTask* nodep) override {
         if (!nodep->lhsp()->isWide()) puts("(void)");
         iterateAndNextNull(nodep->lhsp());
         if (!nodep->lhsp()->isWide()) puts(";");
     }
-    virtual void visit(AstSystemT* nodep) override {
+    void visit(AstSystemT* nodep) override {
         puts("(void)VL_SYSTEM_I");
         emitIQW(nodep->lhsp());
         puts("(");
@@ -798,7 +798,7 @@ public:
         iterateAndNextNull(nodep->lhsp());
         puts(");\n");
     }
-    virtual void visit(AstSystemF* nodep) override {
+    void visit(AstSystemF* nodep) override {
         puts("VL_SYSTEM_I");
         emitIQW(nodep->lhsp());
         puts("(");
@@ -810,20 +810,20 @@ public:
         iterateAndNextNull(nodep->lhsp());
         puts(")");
     }
-    virtual void visit(AstJumpBlock* nodep) override {
+    void visit(AstJumpBlock* nodep) override {
         nodep->labelNum(++m_labelNum);
         puts("{\n");  // Make it visually obvious label jumps outside these
         iterateAndNextNull(nodep->stmtsp());
         iterateAndNextNull(nodep->endStmtsp());
         puts("}\n");
     }
-    virtual void visit(AstJumpGo* nodep) override {
+    void visit(AstJumpGo* nodep) override {
         puts("goto __Vlabel" + cvtToStr(nodep->labelp()->blockp()->labelNum()) + ";\n");
     }
-    virtual void visit(AstJumpLabel* nodep) override {
+    void visit(AstJumpLabel* nodep) override {
         puts("__Vlabel" + cvtToStr(nodep->blockp()->labelNum()) + ": ;\n");
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         iterateAndNextNull(nodep->precondsp());
         puts("while (");
         iterateAndNextNull(nodep->condp());
@@ -833,7 +833,7 @@ public:
         iterateAndNextNull(nodep->precondsp());  // Need to recompute before next loop
         puts("}\n");
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         puts("if (");
         if (!nodep->branchPred().unknown()) {
             puts(nodep->branchPred().ascii());
@@ -857,7 +857,7 @@ public:
             }
         }
     }
-    virtual void visit(AstExprStmt* nodep) override {
+    void visit(AstExprStmt* nodep) override {
         // GCC allows compound statements in expressions, but this is not standard.
         // So we use an immediate-evaluation lambda and comma operator
         putbs("([&]() {\n");
@@ -866,7 +866,7 @@ public:
         iterateAndNextNull(nodep->resultp());
         puts(")");
     }
-    virtual void visit(AstStop* nodep) override {
+    void visit(AstStop* nodep) override {
         puts("VL_STOP_MT(");
         putsQuoted(protect(nodep->fileline()->filename()));
         puts(", ");
@@ -874,38 +874,38 @@ public:
         puts(", \"\"");
         puts(");\n");
     }
-    virtual void visit(AstFinish* nodep) override {
+    void visit(AstFinish* nodep) override {
         puts("VL_FINISH_MT(");
         putsQuoted(protect(nodep->fileline()->filename()));
         puts(", ");
         puts(cvtToStr(nodep->fileline()->lineno()));
         puts(", \"\");\n");
     }
-    virtual void visit(AstPrintTimeScale* nodep) override {
+    void visit(AstPrintTimeScale* nodep) override {
         puts("VL_PRINTTIMESCALE(");
         putsQuoted(protect(nodep->name()));
         puts(", ");
         putsQuoted(nodep->timeunit().ascii());
         puts(", vlSymsp->_vm_contextp__);\n");
     }
-    virtual void visit(AstRand* nodep) override {
+    void visit(AstRand* nodep) override {
         emitOpName(nodep, nodep->emitC(), nodep->seedp(), nullptr, nullptr);
     }
-    virtual void visit(AstTime* nodep) override {
+    void visit(AstTime* nodep) override {
         puts("VL_TIME_UNITED_Q(");
         if (nodep->timeunit().isNone()) nodep->v3fatalSrc("$time has no units");
         puts(cvtToStr(nodep->timeunit().multiplier()
                       / v3Global.rootp()->timeprecision().multiplier()));
         puts(")");
     }
-    virtual void visit(AstTimeD* nodep) override {
+    void visit(AstTimeD* nodep) override {
         puts("VL_TIME_UNITED_D(");
         if (nodep->timeunit().isNone()) nodep->v3fatalSrc("$realtime has no units");
         puts(cvtToStr(nodep->timeunit().multiplier()
                       / v3Global.rootp()->timeprecision().multiplier()));
         puts(")");
     }
-    virtual void visit(AstTimeFormat* nodep) override {
+    void visit(AstTimeFormat* nodep) override {
         puts("VL_TIMEFORMAT_IINI(");
         iterateAndNextNull(nodep->unitsp());
         puts(", ");
@@ -916,7 +916,7 @@ public:
         iterateAndNextNull(nodep->widthp());
         puts(", vlSymsp->_vm_contextp__);\n");
     }
-    virtual void visit(AstNodeSimpleText* nodep) override {
+    void visit(AstNodeSimpleText* nodep) override {
         const string text = m_inUC && m_useSelfForThis
                                 ? VString::replaceWord(nodep->text(), "this", "vlSelf")
                                 : nodep->text();
@@ -926,29 +926,29 @@ public:
             ofp()->putsNoTracking(text);
         }
     }
-    virtual void visit(AstTextBlock* nodep) override {
+    void visit(AstTextBlock* nodep) override {
         visit(static_cast<AstNodeSimpleText*>(nodep));
         for (AstNode* childp = nodep->nodesp(); childp; childp = childp->nextp()) {
             iterate(childp);
             if (nodep->commas() && childp->nextp()) puts(", ");
         }
     }
-    virtual void visit(AstCStmt* nodep) override {
+    void visit(AstCStmt* nodep) override {
         putbs("");
         iterateAndNextNull(nodep->bodysp());
     }
-    virtual void visit(AstCMath* nodep) override {
+    void visit(AstCMath* nodep) override {
         putbs("");
         iterateAndNextNull(nodep->bodysp());
     }
-    virtual void visit(AstUCStmt* nodep) override {
+    void visit(AstUCStmt* nodep) override {
         VL_RESTORER(m_inUC);
         m_inUC = true;
         putsDecoration(ifNoProtect("// $c statement at " + nodep->fileline()->ascii() + "\n"));
         iterateAndNextNull(nodep->bodysp());
         puts("\n");
     }
-    virtual void visit(AstUCFunc* nodep) override {
+    void visit(AstUCFunc* nodep) override {
         VL_RESTORER(m_inUC);
         m_inUC = true;
         puts("\n");
@@ -958,10 +958,10 @@ public:
     }
 
     // Operators
-    virtual void visit(AstNodeTermop* nodep) override {
+    void visit(AstNodeTermop* nodep) override {
         emitOpName(nodep, nodep->emitC(), nullptr, nullptr, nullptr);
     }
-    virtual void visit(AstNodeUniop* nodep) override {
+    void visit(AstNodeUniop* nodep) override {
         if (nodep->emitCheckMaxWords()
             && (nodep->widthWords() > VL_MULS_MAX_WORDS
                 || nodep->lhsp()->widthWords() > VL_MULS_MAX_WORDS)) {
@@ -981,7 +981,7 @@ public:
             emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nullptr, nullptr);
         }
     }
-    virtual void visit(AstNodeBiop* nodep) override {
+    void visit(AstNodeBiop* nodep) override {
         if (nodep->emitCheckMaxWords() && nodep->widthWords() > VL_MULS_MAX_WORDS) {
             nodep->v3warn(
                 E_UNSUPPORTED,
@@ -1001,11 +1001,11 @@ public:
             emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nullptr);
         }
     }
-    virtual void visit(AstNodeTriop* nodep) override {
+    void visit(AstNodeTriop* nodep) override {
         UASSERT_OBJ(!emitSimpleOk(nodep), nodep, "Triop cannot be described in a simple way");
         emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nodep->thsp());
     }
-    virtual void visit(AstRedXor* nodep) override {
+    void visit(AstRedXor* nodep) override {
         if (nodep->lhsp()->isWide()) {
             visit(static_cast<AstNodeUniop*>(nodep));
         } else {
@@ -1021,7 +1021,7 @@ public:
             puts(")");
         }
     }
-    virtual void visit(AstCCast* nodep) override {
+    void visit(AstCCast* nodep) override {
         // Extending a value of the same word width is just a NOP.
         if (nodep->size() <= VL_IDATASIZE) {
             puts("(IData)(");
@@ -1031,7 +1031,7 @@ public:
         iterateAndNextNull(nodep->lhsp());
         puts(")");
     }
-    virtual void visit(AstNodeCond* nodep) override {
+    void visit(AstNodeCond* nodep) override {
         // 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());
@@ -1045,12 +1045,12 @@ public:
             puts(")");
         }
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         iterateAndNextNull(nodep->fromp());
         putbs("->");
         puts(nodep->varp()->nameProtect());
     }
-    virtual void visit(AstNullCheck* nodep) override {
+    void visit(AstNullCheck* nodep) override {
         puts("VL_NULL_CHECK(");
         iterateAndNextNull(nodep->lhsp());
         puts(", ");
@@ -1059,17 +1059,17 @@ public:
         puts(cvtToStr(nodep->fileline()->lineno()));
         puts(")");
     }
-    virtual void visit(AstNewCopy* nodep) override {
+    void visit(AstNewCopy* nodep) override {
         puts("std::make_shared<" + prefixNameProtect(nodep->dtypep()) + ">(");
         puts("*");  // i.e. make into a reference
         iterateAndNextNull(nodep->rhsp());
         puts(")");
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         // Note ASSIGN checks for this on a LHS
         emitOpName(nodep, nodep->emitC(), nodep->fromp(), nodep->lsbp(), nodep->thsp());
     }
-    virtual void visit(AstReplicate* nodep) override {
+    void visit(AstReplicate* nodep) override {
         if (nodep->lhsp()->widthMin() == 1 && !nodep->isWide()) {
             UASSERT_OBJ((static_cast<int>(VN_AS(nodep->rhsp(), Const)->toUInt())
                          * nodep->lhsp()->widthMin())
@@ -1088,7 +1088,7 @@ public:
             emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nullptr);
         }
     }
-    virtual void visit(AstStreamL* nodep) override {
+    void visit(AstStreamL* nodep) override {
         // Attempt to use a "fast" stream function for slice size = power of 2
         if (!nodep->isWide()) {
             const uint32_t isPow2 = VN_AS(nodep->rhsp(), Const)->num().countOnes() == 1;
@@ -1110,14 +1110,14 @@ public:
         emitOpName(nodep, "VL_STREAML_%nq%lq%rq(%lw, %P, %li, %ri)", nodep->lhsp(), nodep->rhsp(),
                    nullptr);
     }
-    virtual void visit(AstCastDynamic* nodep) override {
+    void visit(AstCastDynamic* nodep) override {
         putbs("VL_CAST_DYNAMIC(");
         iterateAndNextNull(nodep->lhsp());
         puts(", ");
         iterateAndNextNull(nodep->rhsp());
         puts(")");
     }
-    virtual void visit(AstCountBits* nodep) override {
+    void visit(AstCountBits* nodep) override {
         putbs("VL_COUNTBITS_");
         emitIQW(nodep->lhsp());
         puts("(");
@@ -1137,9 +1137,9 @@ public:
         iterateAndNextNull(nodep->fhsp());
         puts(")");
     }
-    virtual void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
+    void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
     // Terminals
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         const AstVar* const varp = nodep->varp();
         const AstNodeModule* const varModp = EmitCParentModule::get(varp);
         if (isConstPoolMod(varModp)) {
@@ -1156,14 +1156,14 @@ public:
         }
         puts(nodep->varp()->nameProtect());
     }
-    virtual void visit(AstAddrOfCFunc* nodep) override {
+    void visit(AstAddrOfCFunc* nodep) override {
         // Note: Can be thought to handle more, but this is all that is needed right now
         const AstCFunc* const funcp = nodep->funcp();
         UASSERT_OBJ(funcp->isLoose(), nodep, "Cannot take address of non-loose method");
         puts("&");
         puts(funcNameProtect(funcp));
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         if (m_emitConstInit) {
             EmitCConstInit::visit(nodep);
         } else if (nodep->isWide()) {
@@ -1176,12 +1176,12 @@ public:
     }
 
     //
-    virtual void visit(AstMTaskBody* nodep) override {
+    void visit(AstMTaskBody* nodep) override {
         VL_RESTORER(m_useSelfForThis);
         m_useSelfForThis = true;
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstConsAssoc* nodep) override {
+    void visit(AstConsAssoc* nodep) override {
         putbs(nodep->dtypep()->cType("", false, false));
         puts("()");
         if (nodep->defaultp()) {
@@ -1190,7 +1190,7 @@ public:
             puts(")");
         }
     }
-    virtual void visit(AstSetAssoc* nodep) override {
+    void visit(AstSetAssoc* nodep) override {
         iterateAndNextNull(nodep->lhsp());
         putbs(".set(");
         iterateAndNextNull(nodep->keyp());
@@ -1199,7 +1199,7 @@ public:
         iterateAndNextNull(nodep->valuep());
         puts(")");
     }
-    virtual void visit(AstConsWildcard* nodep) override {
+    void visit(AstConsWildcard* nodep) override {
         putbs(nodep->dtypep()->cType("", false, false));
         puts("()");
         if (nodep->defaultp()) {
@@ -1208,7 +1208,7 @@ public:
             puts(")");
         }
     }
-    virtual void visit(AstSetWildcard* nodep) override {
+    void visit(AstSetWildcard* nodep) override {
         iterateAndNextNull(nodep->lhsp());
         putbs(".set(");
         iterateAndNextNull(nodep->keyp());
@@ -1217,7 +1217,7 @@ public:
         iterateAndNextNull(nodep->valuep());
         puts(")");
     }
-    virtual void visit(AstConsDynArray* nodep) override {
+    void visit(AstConsDynArray* nodep) override {
         putbs(nodep->dtypep()->cType("", false, false));
         if (!nodep->lhsp()) {
             puts("()");
@@ -1232,7 +1232,7 @@ public:
             puts(")");
         }
     }
-    virtual void visit(AstConsQueue* nodep) override {
+    void visit(AstConsQueue* nodep) override {
         putbs(nodep->dtypep()->cType("", false, false));
         if (!nodep->lhsp()) {
             puts("()");
@@ -1247,22 +1247,22 @@ public:
             puts(")");
         }
     }
-    virtual void visit(AstCReset* nodep) override {
+    void visit(AstCReset* nodep) override {
         AstVar* const varp = nodep->varrefp()->varp();
         emitVarReset(varp);
     }
-    virtual void visit(AstExecGraph* nodep) override {
+    void visit(AstExecGraph* nodep) override {
         // The location of the AstExecGraph within the containing AstCFunc is where we want to
         // invoke the graph and wait for it to complete. Emitting the children does just that.
         UASSERT_OBJ(!nodep->mTaskBodiesp(), nodep, "These should have been lowered");
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstChangeDet* nodep) override {  //
+    void visit(AstChangeDet* nodep) override {  //
         m_blkChangeDetVec.push_back(nodep);
     }
 
     // Default
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         puts(string("\n???? // ") + nodep->prettyTypeName() + "\n");
         iterateChildren(nodep);
         // LCOV_EXCL_START
@@ -1280,7 +1280,7 @@ public:
         m_trackText = trackText;
         iterate(nodep);
     }
-    virtual ~EmitCFunc() override = default;
+    ~EmitCFunc() override = default;
 };
 
 #endif  // guard

src/V3EmitCHeaders.cpp

@@ -326,7 +326,7 @@ class EmitCHeader final : public EmitCConstInit {
         // Close output file
         VL_DO_CLEAR(delete m_ofp, m_ofp = nullptr);
     }
-    virtual ~EmitCHeader() override = default;
+    ~EmitCHeader() override = default;
 
 public:
     static void main(const AstNodeModule* modp) { EmitCHeader emitCHeader(modp); }

src/V3EmitCImp.cpp

@@ -68,59 +68,59 @@ class EmitCGatherDependencies final : VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstCCall* nodep) override {
+    void visit(AstCCall* nodep) override {
         addSelfDependency(nodep->selfPointer(), nodep->funcp());
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstCNew* nodep) override {
+    void visit(AstCNew* nodep) override {
         addDTypeDependency(nodep->dtypep());
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstCMethodCall* nodep) override {
+    void visit(AstCMethodCall* nodep) override {
         addDTypeDependency(nodep->fromp()->dtypep());
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstNewCopy* nodep) override {
+    void visit(AstNewCopy* nodep) override {
         addDTypeDependency(nodep->dtypep());
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         addDTypeDependency(nodep->fromp()->dtypep());
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         addSelfDependency(nodep->selfPointer(), nodep->varp());
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstCoverDecl* nodep) override {
+    void visit(AstCoverDecl* nodep) override {
         addSymsDependency();
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstCoverInc* nodep) override {
+    void visit(AstCoverInc* nodep) override {
         addSymsDependency();
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstDumpCtl* nodep) override {
+    void visit(AstDumpCtl* nodep) override {
         addSymsDependency();
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstScopeName* nodep) override {
+    void visit(AstScopeName* nodep) override {
         addSymsDependency();
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstPrintTimeScale* nodep) override {
+    void visit(AstPrintTimeScale* nodep) override {
         addSymsDependency();
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstTimeFormat* nodep) override {
+    void visit(AstTimeFormat* nodep) override {
         addSymsDependency();
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstNodeSimpleText* nodep) override {
+    void visit(AstNodeSimpleText* nodep) override {
         if (nodep->text().find("vlSymsp") != string::npos) addSymsDependency();
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
+    void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
 
     // CONSTRUCTOR
     explicit EmitCGatherDependencies(AstCFunc* cfuncp) {
@@ -512,7 +512,7 @@ class EmitCImp final : EmitCFunc {
     }
 
     // VISITORS
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (splitNeeded()) {
             // Splitting file, so using parallel build.
             v3Global.useParallelBuild(true);
@@ -544,7 +544,7 @@ class EmitCImp final : EmitCFunc {
         // Emit implementations of all AstCFunc
         emitCFuncImp(modp);
     }
-    virtual ~EmitCImp() override = default;
+    ~EmitCImp() override = default;
 
 public:
     static void main(const AstNodeModule* modp, bool slow, std::deque<AstCFile*>& cfilesr) {
@@ -823,7 +823,7 @@ class EmitCTrace final : EmitCFunc {
 
     // VISITORS
     using EmitCFunc::visit;  // Suppress hidden overloaded virtual function warning
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (!nodep->isTrace()) return;
         if (nodep->slow() != m_slow) return;
 
@@ -838,17 +838,17 @@ class EmitCTrace final : EmitCFunc {
 
         EmitCFunc::visit(nodep);
     }
-    virtual void visit(AstTracePushNamePrefix* nodep) override {
+    void visit(AstTracePushNamePrefix* nodep) override {
         puts("tracep->pushNamePrefix(");
         putsQuoted(VIdProtect::protectWordsIf(nodep->prefix(), nodep->protect()));
         puts(");\n");
     }
-    virtual void visit(AstTracePopNamePrefix* nodep) override {  //
+    void visit(AstTracePopNamePrefix* nodep) override {  //
         puts("tracep->popNamePrefix(");
         puts(cvtToStr(nodep->count()));
         puts(");\n");
     }
-    virtual void visit(AstTraceDecl* nodep) override {
+    void visit(AstTraceDecl* nodep) override {
         const int enumNum = emitTraceDeclDType(nodep->dtypep());
         if (nodep->arrayRange().ranged()) {
             puts("for (int i = 0; i < " + cvtToStr(nodep->arrayRange().elements()) + "; ++i) {\n");
@@ -859,7 +859,7 @@ class EmitCTrace final : EmitCFunc {
             puts("\n");
         }
     }
-    virtual void visit(AstTraceInc* nodep) override {
+    void visit(AstTraceInc* nodep) override {
         if (nodep->declp()->arrayRange().ranged()) {
             // It traces faster if we unroll the loop
             for (int i = 0; i < nodep->declp()->arrayRange().elements(); i++) {
@@ -883,7 +883,7 @@ class EmitCTrace final : EmitCFunc {
         // Close output file
         VL_DO_CLEAR(delete m_ofp, m_ofp = nullptr);
     }
-    virtual ~EmitCTrace() override = default;
+    ~EmitCTrace() override = default;
 
 public:
     static void main(AstNodeModule* modp, bool slow, std::deque<AstCFile*>& cfilesr) {

src/V3EmitCInlines.cpp

@@ -32,18 +32,18 @@ class EmitCInlines final : EmitCBaseVisitor {
     // METHODS
 
     // VISITORS
-    virtual void visit(AstCNew* nodep) override {
+    void visit(AstCNew* nodep) override {
         if (v3Global.opt.savable())
             v3warn(E_UNSUPPORTED, "Unsupported: --savable with dynamic new");
         iterateChildren(nodep);
     }
-    virtual void visit(AstDumpCtl* nodep) override {
+    void visit(AstDumpCtl* nodep) override {
         if (v3Global.opt.trace()) v3Global.needTraceDumper(true);
         iterateChildren(nodep);
     }
 
     //---------------------------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     explicit EmitCInlines(AstNetlist* nodep) { iterate(nodep); }

src/V3EmitCMain.cpp

@@ -32,7 +32,7 @@ class EmitCMain final : EmitCBaseVisitor {
 
     // VISITORS
     // This visitor doesn't really iterate, but exist to appease base class
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }  // LCOV_EXCL_LINE
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }  // LCOV_EXCL_LINE
 
 public:
     // CONSTRUCTORS

src/V3EmitCModel.cpp

@@ -190,7 +190,7 @@ class EmitCModel final : public EmitCFunc {
                  + "C* tfp, int levels, int options = 0);\n");
             if (optSystemC()) {
                 puts("/// SC tracing; avoid overloaded virtual function lint warning\n");
-                puts("virtual void trace(sc_trace_file* tfp) const override { "
+                puts("void trace(sc_trace_file* tfp) const override { "
                      "::sc_core::sc_module::trace(tfp); }\n");
             }
         }

src/V3EmitCSyms.cpp

@@ -258,7 +258,7 @@ class EmitCSyms final : EmitCBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Collect list of scopes
         iterateChildren(nodep);
         varsExpand();
@@ -280,8 +280,8 @@ class EmitCSyms final : EmitCBaseVisitor {
             if (!m_dpiHdrOnly) emitDpiImp();
         }
     }
-    virtual void visit(AstConstPool* nodep) override {}  // Ignore
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstConstPool* nodep) override {}  // Ignore
+    void visit(AstNodeModule* nodep) override {
         nameCheck(nodep);
         VL_RESTORER(m_modp);
         {
@@ -289,7 +289,7 @@ class EmitCSyms final : EmitCBaseVisitor {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstCellInline* nodep) override {
+    void visit(AstCellInline* nodep) override {
         if (v3Global.opt.vpi()) {
             const string type
                 = (nodep->origModName() == "__BEGIN__") ? "SCOPE_OTHER" : "SCOPE_MODULE";
@@ -300,7 +300,7 @@ class EmitCSyms final : EmitCBaseVisitor {
                 std::make_pair(name, ScopeData(scopeSymString(name), name_dedot, timeunit, type)));
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         if (VN_IS(m_modp, Class)) return;  // The ClassPackage is what is visible
         nameCheck(nodep);
 
@@ -315,7 +315,7 @@ class EmitCSyms final : EmitCBaseVisitor {
                                                         timeunit, type)));
         }
     }
-    virtual void visit(AstScopeName* nodep) override {
+    void visit(AstScopeName* nodep) override {
         const string name = nodep->scopeSymName();
         // UINFO(9,"scnameins sp "<<nodep->name()<<" sp "<<nodep->scopePrettySymName()
         // <<" ss"<<name<<endl);
@@ -337,19 +337,19 @@ class EmitCSyms final : EmitCBaseVisitor {
             }
         }
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         nameCheck(nodep);
         iterateChildren(nodep);
         if (nodep->isSigUserRdPublic() && !m_cfuncp)
             m_modVars.emplace_back(std::make_pair(m_modp, nodep));
     }
-    virtual void visit(AstCoverDecl* nodep) override {
+    void visit(AstCoverDecl* nodep) override {
         // Assign numbers to all bins, so we know how big of an array to use
         if (!nodep->dataDeclNullp()) {  // else duplicate we don't need code for
             nodep->binNum(m_coverBins++);
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         nameCheck(nodep);
         if (nodep->dpiImportPrototype() || nodep->dpiExportDispatcher()) m_dpis.push_back(nodep);
         VL_RESTORER(m_cfuncp);
@@ -360,8 +360,8 @@ class EmitCSyms final : EmitCBaseVisitor {
     }
 
     //---------------------------------------
-    virtual void visit(AstConst*) override {}
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstConst*) override {}
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     explicit EmitCSyms(AstNetlist* nodep, bool dpiHdrOnly)

src/V3EmitV.cpp

@@ -53,14 +53,14 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override { iterateAndNextConstNull(nodep->modulesp()); }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNetlist* nodep) override { iterateAndNextConstNull(nodep->modulesp()); }
+    void visit(AstNodeModule* nodep) override {
         putfs(nodep, nodep->verilogKwd() + " " + prefixNameProtect(nodep) + ";\n");
         iterateChildrenConst(nodep);
         putqs(nodep, "end" + nodep->verilogKwd() + "\n");
     }
-    virtual void visit(AstPort* nodep) override {}
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstPort* nodep) override {}
+    void visit(AstNodeFTask* nodep) override {
         putfs(nodep, nodep->isFunction() ? "function" : "task");
         puts(" ");
         puts(nodep->prettyName());
@@ -70,7 +70,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         putfs(nodep, nodep->isFunction() ? "endfunction\n" : "endtask\n");
     }
 
-    virtual void visit(AstBegin* nodep) override {
+    void visit(AstBegin* nodep) override {
         if (nodep->name() == "") {
             putbs("begin\n");
         } else {
@@ -79,7 +79,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateChildrenConst(nodep);
         puts("end\n");
     }
-    virtual void visit(AstFork* nodep) override {
+    void visit(AstFork* nodep) override {
         if (nodep->name() == "") {
             putbs("fork\n");
         } else {
@@ -89,19 +89,19 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         puts(nodep->joinType().verilogKwd());
         puts("\n");
     }
-    virtual void visit(AstFinal* nodep) override {
+    void visit(AstFinal* nodep) override {
         putfs(nodep, "final begin\n");
         iterateChildrenConst(nodep);
         putqs(nodep, "end\n");
     }
-    virtual void visit(AstInitial* nodep) override {
+    void visit(AstInitial* nodep) override {
         putfs(nodep, "initial begin\n");
         iterateChildrenConst(nodep);
         putqs(nodep, "end\n");
     }
-    virtual void visit(AstInitialAutomatic* nodep) override { iterateChildrenConst(nodep); }
-    virtual void visit(AstInitialStatic* nodep) override { iterateChildrenConst(nodep); }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstInitialAutomatic* nodep) override { iterateChildrenConst(nodep); }
+    void visit(AstInitialStatic* nodep) override { iterateChildrenConst(nodep); }
+    void visit(AstAlways* nodep) override {
         putfs(nodep, "always ");
         if (m_sensesp) {
             iterateAndNextConstNull(m_sensesp);
@@ -113,7 +113,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->bodysp());
         putqs(nodep, "end\n");
     }
-    virtual void visit(AstAlwaysPublic* nodep) override {
+    void visit(AstAlwaysPublic* nodep) override {
         putfs(nodep, "/*verilator public_flat_rw ");
         if (m_sensesp) {
             iterateAndNextConstNull(m_sensesp);
@@ -125,43 +125,43 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->bodysp());
         putqs(nodep, "*/\n");
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         if (VN_IS(nodep, AssignForce)) puts("force ");
         iterateAndNextConstNull(nodep->lhsp());
         putfs(nodep, " " + nodep->verilogKwd() + " ");
         iterateAndNextConstNull(nodep->rhsp());
         if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         iterateAndNextConstNull(nodep->lhsp());
         putfs(nodep, " <= ");
         iterateAndNextConstNull(nodep->rhsp());
         puts(";\n");
     }
-    virtual void visit(AstAssignAlias* nodep) override {
+    void visit(AstAssignAlias* nodep) override {
         putbs("alias ");
         iterateAndNextConstNull(nodep->lhsp());
         putfs(nodep, " = ");
         iterateAndNextConstNull(nodep->rhsp());
         if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         putfs(nodep, "assign ");
         iterateAndNextConstNull(nodep->lhsp());
         putbs(" = ");
         iterateAndNextConstNull(nodep->rhsp());
         if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstRelease* nodep) override {
+    void visit(AstRelease* nodep) override {
         puts("release ");
         iterateAndNextConstNull(nodep->lhsp());
         if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstBreak*) override {
+    void visit(AstBreak*) override {
         putbs("break");
         if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstSenTree* nodep) override {
+    void visit(AstSenTree* nodep) override {
         // AstSenItem is called for dumping in isolation by V3Order
         putfs(nodep, "@(");
         for (AstNode* expp = nodep->sensesp(); expp; expp = expp->nextp()) {
@@ -170,13 +170,13 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts(")");
     }
-    virtual void visit(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         putfs(nodep, "");
         puts(nodep->edgeType().verilogKwd());
         if (nodep->sensp()) puts(" ");
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstNodeCase* nodep) override {
+    void visit(AstNodeCase* nodep) override {
         putfs(nodep, "");
         if (const AstCase* const casep = VN_CAST(nodep, Case)) {
             if (casep->priorityPragma()) puts("priority ");
@@ -197,7 +197,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->itemsp());
         putqs(nodep, "endcase\n");
     }
-    virtual void visit(AstCaseItem* nodep) override {
+    void visit(AstCaseItem* nodep) override {
         if (nodep->condsp()) {
             iterateAndNextConstNull(nodep->condsp());
         } else {
@@ -207,17 +207,17 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->bodysp());
         putqs(nodep, "end\n");
     }
-    virtual void visit(AstComment* nodep) override {
+    void visit(AstComment* nodep) override {
         puts(std::string{"// "} + nodep->name() + "\n");
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstContinue*) override {
+    void visit(AstContinue*) override {
         putbs("continue");
         if (!m_suppressSemi) puts(";\n");
     }
-    virtual void visit(AstCoverDecl*) override {}  // N/A
-    virtual void visit(AstCoverInc*) override {}  // N/A
-    virtual void visit(AstCoverToggle*) override {}  // N/A
+    void visit(AstCoverDecl*) override {}  // N/A
+    void visit(AstCoverInc*) override {}  // N/A
+    void visit(AstCoverToggle*) override {}  // N/A
 
     void visitNodeDisplay(AstNode* nodep, AstNode* fileOrStrgp, const string& text,
                           AstNode* exprsp) {
@@ -234,26 +234,26 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts(");\n");
     }
-    virtual void visit(AstDisable* nodep) override { putbs("disable " + nodep->name() + ";\n"); }
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisable* nodep) override { putbs("disable " + nodep->name() + ";\n"); }
+    void visit(AstDisplay* nodep) override {
         visitNodeDisplay(nodep, nodep->filep(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
     }
-    virtual void visit(AstElabDisplay* nodep) override {
+    void visit(AstElabDisplay* nodep) override {
         visitNodeDisplay(nodep, nullptr, nodep->fmtp()->text(), nodep->fmtp()->exprsp());
     }
-    virtual void visit(AstFScanF* nodep) override {
+    void visit(AstFScanF* nodep) override {
         visitNodeDisplay(nodep, nodep->filep(), nodep->text(), nodep->exprsp());
     }
-    virtual void visit(AstSScanF* nodep) override {
+    void visit(AstSScanF* nodep) override {
         visitNodeDisplay(nodep, nodep->fromp(), nodep->text(), nodep->exprsp());
     }
-    virtual void visit(AstSFormat* nodep) override {
+    void visit(AstSFormat* nodep) override {
         visitNodeDisplay(nodep, nodep->lhsp(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         visitNodeDisplay(nodep, nullptr, nodep->text(), nodep->exprsp());
     }
-    virtual void visit(AstFOpen* nodep) override {
+    void visit(AstFOpen* nodep) override {
         putfs(nodep, nodep->verilogKwd());
         putbs("(");
         iterateAndNextConstNull(nodep->filenamep());
@@ -261,36 +261,34 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->modep());
         puts(");\n");
     }
-    virtual void visit(AstFOpenMcd* nodep) override {
+    void visit(AstFOpenMcd* nodep) override {
         putfs(nodep, nodep->verilogKwd());
         putbs("(");
         iterateAndNextConstNull(nodep->filenamep());
         puts(");\n");
     }
-    virtual void visit(AstFClose* nodep) override {
+    void visit(AstFClose* nodep) override {
         putfs(nodep, nodep->verilogKwd());
         putbs("(");
         if (nodep->filep()) iterateAndNextConstNull(nodep->filep());
         puts(");\n");
     }
-    virtual void visit(AstFFlush* nodep) override {
+    void visit(AstFFlush* nodep) override {
         putfs(nodep, nodep->verilogKwd());
         putbs("(");
         if (nodep->filep()) iterateAndNextConstNull(nodep->filep());
         puts(");\n");
     }
-    virtual void visit(AstJumpBlock* nodep) override {
+    void visit(AstJumpBlock* nodep) override {
         putbs("begin : label" + cvtToStr(nodep->labelNum()) + "\n");
         if (nodep->stmtsp()) iterateAndNextConstNull(nodep->stmtsp());
         puts("end\n");
     }
-    virtual void visit(AstJumpGo* nodep) override {
+    void visit(AstJumpGo* nodep) override {
         putbs("disable label" + cvtToStr(nodep->labelp()->blockp()->labelNum()) + ";\n");
     }
-    virtual void visit(AstJumpLabel* nodep) override {
-        putbs("// " + cvtToStr(nodep->blockp()) + ":\n");
-    }
-    virtual void visit(AstNodeReadWriteMem* nodep) override {
+    void visit(AstJumpLabel* nodep) override { putbs("// " + cvtToStr(nodep->blockp()) + ":\n"); }
+    void visit(AstNodeReadWriteMem* nodep) override {
         putfs(nodep, nodep->verilogKwd());
         putbs("(");
         if (nodep->filenamep()) iterateAndNextConstNull(nodep->filenamep());
@@ -306,17 +304,17 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts(");\n");
     }
-    virtual void visit(AstSysFuncAsTask* nodep) override {
+    void visit(AstSysFuncAsTask* nodep) override {
         iterateAndNextConstNull(nodep->lhsp());
         puts(";\n");
     }
-    virtual void visit(AstSysIgnore* nodep) override {
+    void visit(AstSysIgnore* nodep) override {
         putfs(nodep, nodep->verilogKwd());
         putbs("(");
         iterateAndNextConstNull(nodep->exprsp());
         puts(");\n");
     }
-    virtual void visit(AstNodeFor* nodep) override {
+    void visit(AstNodeFor* nodep) override {
         putfs(nodep, "for (");
         {
             VL_RESTORER(m_suppressSemi);
@@ -331,14 +329,14 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->bodysp());
         putqs(nodep, "end\n");
     }
-    virtual void visit(AstRepeat* nodep) override {
+    void visit(AstRepeat* nodep) override {
         putfs(nodep, "repeat (");
         iterateAndNextConstNull(nodep->countp());
         puts(") begin\n");
         iterateAndNextConstNull(nodep->bodysp());
         putfs(nodep, "end\n");
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         iterateAndNextConstNull(nodep->precondsp());
         putfs(nodep, "while (");
         iterateAndNextConstNull(nodep->condp());
@@ -348,7 +346,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->precondsp());  // Need to recompute before next loop
         putfs(nodep, "end\n");
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         putfs(nodep, "");
         if (const AstIf* const ifp = VN_CAST(nodep, If)) {
             if (ifp->priorityPragma()) puts("priority ");
@@ -366,7 +364,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         putqs(nodep, "end\n");
     }
-    virtual void visit(AstPast* nodep) override {
+    void visit(AstPast* nodep) override {
         putfs(nodep, "$past(");
         iterateAndNextConstNull(nodep->exprp());
         if (nodep->ticksp()) {
@@ -375,21 +373,21 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts(")");
     }
-    virtual void visit(AstReturn* nodep) override {
+    void visit(AstReturn* nodep) override {
         putfs(nodep, "return ");
         iterateAndNextConstNull(nodep->lhsp());
         puts(";\n");
     }
-    virtual void visit(AstStop* nodep) override { putfs(nodep, "$stop;\n"); }
-    virtual void visit(AstFinish* nodep) override { putfs(nodep, "$finish;\n"); }
-    virtual void visit(AstNodeSimpleText* nodep) override {
+    void visit(AstStop* nodep) override { putfs(nodep, "$stop;\n"); }
+    void visit(AstFinish* nodep) override { putfs(nodep, "$finish;\n"); }
+    void visit(AstNodeSimpleText* nodep) override {
         if (nodep->tracking() || m_trackText) {
             puts(nodep->text());
         } else {
             putsNoTracking(nodep->text());
         }
     }
-    virtual void visit(AstTextBlock* nodep) override {
+    void visit(AstTextBlock* nodep) override {
         visit(static_cast<AstNodeSimpleText*>(nodep));
         {
             VL_RESTORER(m_suppressSemi);
@@ -400,23 +398,23 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
             }
         }
     }
-    virtual void visit(AstScopeName* nodep) override {}
-    virtual void visit(AstCStmt* nodep) override {
+    void visit(AstScopeName* nodep) override {}
+    void visit(AstCStmt* nodep) override {
         putfs(nodep, "$_CSTMT(");
         iterateAndNextConstNull(nodep->bodysp());
         puts(");\n");
     }
-    virtual void visit(AstCMath* nodep) override {
+    void visit(AstCMath* nodep) override {
         putfs(nodep, "$_CMATH(");
         iterateAndNextConstNull(nodep->bodysp());
         puts(");\n");
     }
-    virtual void visit(AstUCStmt* nodep) override {
+    void visit(AstUCStmt* nodep) override {
         putfs(nodep, "$c(");
         iterateAndNextConstNull(nodep->bodysp());
         puts(");\n");
     }
-    virtual void visit(AstUCFunc* nodep) override {
+    void visit(AstUCFunc* nodep) override {
         putfs(nodep, "$c(");
         iterateAndNextConstNull(nodep->bodysp());
         puts(")");
@@ -481,25 +479,23 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
     }
 
-    virtual void visit(AstNodeTermop* nodep) override {
-        emitVerilogFormat(nodep, nodep->emitVerilog());
-    }
-    virtual void visit(AstNodeUniop* nodep) override {
+    void visit(AstNodeTermop* nodep) override { emitVerilogFormat(nodep, nodep->emitVerilog()); }
+    void visit(AstNodeUniop* nodep) override {
         emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp());
     }
-    virtual void visit(AstNodeBiop* nodep) override {
+    void visit(AstNodeBiop* nodep) override {
         emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp());
     }
-    virtual void visit(AstNodeTriop* nodep) override {
+    void visit(AstNodeTriop* nodep) override {
         emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp(),
                           nodep->thsp());
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         iterate(nodep->fromp());
         puts(".");
         puts(nodep->prettyName());
     }
-    virtual void visit(AstAttrOf* nodep) override {
+    void visit(AstAttrOf* nodep) override {
         putfs(nodep, "$_ATTROF(");
         iterateAndNextConstNull(nodep->fromp());
         if (nodep->dimp()) {
@@ -508,7 +504,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts(")");
     }
-    virtual void visit(AstInitArray* nodep) override {
+    void visit(AstInitArray* nodep) override {
         putfs(nodep, "'{");
         int comma = 0;
         const auto& mapr = nodep->map();
@@ -521,7 +517,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts("}");
     }
-    virtual void visit(AstNodeCond* nodep) override {
+    void visit(AstNodeCond* nodep) override {
         putbs("(");
         iterateAndNextConstNull(nodep->condp());
         putfs(nodep, " ? ");
@@ -530,7 +526,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->expr2p());
         puts(")");
     }
-    virtual void visit(AstRange* nodep) override {
+    void visit(AstRange* nodep) override {
         puts("[");
         if (VN_IS(nodep->leftp(), Const) && VN_IS(nodep->rightp(), Const)) {
             // Looks nicer if we print [1:0] rather than [32'sh1:32sh0]
@@ -545,7 +541,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
             puts("]");
         }
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         iterateAndNextConstNull(nodep->fromp());
         puts("[");
         if (VN_IS(nodep->lsbp(), Const)) {
@@ -569,18 +565,18 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts("]");
     }
-    virtual void visit(AstSliceSel* nodep) override {
+    void visit(AstSliceSel* nodep) override {
         iterateAndNextConstNull(nodep->fromp());
         puts(cvtToStr(nodep->declRange()));
     }
-    virtual void visit(AstTypedef* nodep) override {
+    void visit(AstTypedef* nodep) override {
         putfs(nodep, "typedef ");
         iterateAndNextConstNull(nodep->dtypep());
         puts(" ");
         puts(nodep->prettyName());
         puts(";\n");
     }
-    virtual void visit(AstBasicDType* nodep) override {
+    void visit(AstBasicDType* nodep) override {
         if (nodep->isSigned()) putfs(nodep, "signed ");
         putfs(nodep, nodep->prettyName());
         if (nodep->rangep()) {
@@ -593,15 +589,15 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
             puts(":0] ");
         }
     }
-    virtual void visit(AstConstDType* nodep) override {
+    void visit(AstConstDType* nodep) override {
         putfs(nodep, "const ");
         iterate(nodep->subDTypep());
     }
-    virtual void visit(AstNodeArrayDType* nodep) override {
+    void visit(AstNodeArrayDType* nodep) override {
         iterate(nodep->subDTypep());
         iterateAndNextConstNull(nodep->rangep());
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) override {
+    void visit(AstNodeUOrStructDType* nodep) override {
         puts(nodep->verilogKwd() + " ");
         if (nodep->packed()) puts("packed ");
         puts("\n");
@@ -609,12 +605,12 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->membersp());
         puts("}");
     }
-    virtual void visit(AstMemberDType* nodep) override {
+    void visit(AstMemberDType* nodep) override {
         iterate(nodep->subDTypep());
         puts(" ");
         puts(nodep->name());
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         if (nodep->dotted() != "") {
             putfs(nodep, nodep->dotted());
             puts(".");
@@ -626,14 +622,14 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         iterateAndNextConstNull(nodep->pinsp());
         puts(")");
     }
-    virtual void visit(AstArg* nodep) override { iterateAndNextConstNull(nodep->exprp()); }
-    virtual void visit(AstPrintTimeScale* nodep) override {
+    void visit(AstArg* nodep) override { iterateAndNextConstNull(nodep->exprp()); }
+    void visit(AstPrintTimeScale* nodep) override {
         puts(nodep->verilogKwd());
         puts(";\n");
     }
 
     // Terminals
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (nodep->varScopep()) {
             putfs(nodep, nodep->varScopep()->prettyName());
         } else {
@@ -649,7 +645,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
             }
         }
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         putfs(nodep, nodep->dotted());
         puts(".");
         if (nodep->varp()) {
@@ -658,12 +654,12 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
             puts(nodep->prettyName());
         }
     }
-    virtual void visit(AstConst* nodep) override { putfs(nodep, nodep->num().ascii(true, true)); }
+    void visit(AstConst* nodep) override { putfs(nodep, nodep->num().ascii(true, true)); }
 
     // Just iterate
-    virtual void visit(AstTopScope* nodep) override { iterateChildrenConst(nodep); }
-    virtual void visit(AstScope* nodep) override { iterateChildrenConst(nodep); }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstTopScope* nodep) override { iterateChildrenConst(nodep); }
+    void visit(AstScope* nodep) override { iterateChildrenConst(nodep); }
+    void visit(AstVar* nodep) override {
         if (nodep->isIO()) {
             putfs(nodep, nodep->verilogKwd());
             puts(" ");
@@ -691,21 +687,21 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         }
         puts(m_suppressVarSemi ? "\n" : ";\n");
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         m_sensesp = nodep->sensesp();
         iterateAndNextConstNull(nodep->stmtsp());
         m_sensesp = nullptr;
     }
-    virtual void visit(AstParseRef* nodep) override { puts(nodep->prettyName()); }
-    virtual void visit(AstVarScope*) override {}
-    virtual void visit(AstNodeText*) override {}
-    virtual void visit(AstTraceDecl*) override {}
-    virtual void visit(AstTraceInc*) override {}
+    void visit(AstParseRef* nodep) override { puts(nodep->prettyName()); }
+    void visit(AstVarScope*) override {}
+    void visit(AstNodeText*) override {}
+    void visit(AstTraceDecl*) override {}
+    void visit(AstTraceInc*) override {}
     // NOPs
-    virtual void visit(AstPragma*) override {}
-    virtual void visit(AstCell*) override {}  // Handled outside the Visit class
+    void visit(AstPragma*) override {}
+    void visit(AstCell*) override {}  // Handled outside the Visit class
     // Default
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         puts(std::string{"\n???? // "} + nodep->prettyTypeName() + "\n");
         iterateChildrenConst(nodep);
         // Not v3fatalSrc so we keep processing
@@ -720,7 +716,7 @@ public:
     explicit EmitVBaseVisitor(bool suppressUnknown, AstSenTree* domainp)
         : m_suppressUnknown{suppressUnknown}
         , m_sensesp{domainp} {}
-    virtual ~EmitVBaseVisitor() override = default;
+    ~EmitVBaseVisitor() override = default;
 };
 
 //######################################################################
@@ -731,11 +727,11 @@ class EmitVFileVisitor final : public EmitVBaseVisitor {
     V3OutFile* m_ofp;
     // METHODS
     V3OutFile* ofp() const { return m_ofp; }
-    virtual void puts(const string& str) override { ofp()->puts(str); }
-    virtual void putbs(const string& str) override { ofp()->putbs(str); }
-    virtual void putfs(AstNode*, const string& str) override { putbs(str); }
-    virtual void putqs(AstNode*, const string& str) override { putbs(str); }
-    virtual void putsNoTracking(const string& str) override { ofp()->putsNoTracking(str); }
+    void puts(const string& str) override { ofp()->puts(str); }
+    void putbs(const string& str) override { ofp()->putbs(str); }
+    void putfs(AstNode*, const string& str) override { putbs(str); }
+    void putqs(AstNode*, const string& str) override { putbs(str); }
+    void putsNoTracking(const string& str) override { ofp()->putsNoTracking(str); }
 
 public:
     EmitVFileVisitor(AstNode* nodep, V3OutFile* ofp, bool trackText, bool suppressUnknown)
@@ -744,7 +740,7 @@ public:
         m_trackText = trackText;
         iterate(nodep);
     }
-    virtual ~EmitVFileVisitor() override = default;
+    ~EmitVFileVisitor() override = default;
 };
 
 //######################################################################
@@ -754,11 +750,11 @@ class EmitVStreamVisitor final : public EmitVBaseVisitor {
     // MEMBERS
     std::ostream& m_os;
     // METHODS
-    virtual void putsNoTracking(const string& str) override { m_os << str; }
-    virtual void puts(const string& str) override { putsNoTracking(str); }
-    virtual void putbs(const string& str) override { puts(str); }
-    virtual void putfs(AstNode*, const string& str) override { putbs(str); }
-    virtual void putqs(AstNode*, const string& str) override { putbs(str); }
+    void putsNoTracking(const string& str) override { m_os << str; }
+    void puts(const string& str) override { putsNoTracking(str); }
+    void putbs(const string& str) override { puts(str); }
+    void putfs(AstNode*, const string& str) override { putbs(str); }
+    void putqs(AstNode*, const string& str) override { putbs(str); }
 
 public:
     EmitVStreamVisitor(const AstNode* nodep, std::ostream& os)
@@ -766,7 +762,7 @@ public:
         , m_os(os) {  // Need () or GCC 4.8 false warning
         iterate(const_cast<AstNode*>(nodep));
     }
-    virtual ~EmitVStreamVisitor() override = default;
+    ~EmitVStreamVisitor() override = default;
 };
 
 //######################################################################
@@ -779,7 +775,7 @@ class EmitVPrefixedFormatter final : public V3OutFormatter {
     int m_column = 0;  // Rough location; need just zero or non-zero
     FileLine* m_prefixFl;
     // METHODS
-    virtual void putcOutput(char chr) override {
+    void putcOutput(char chr) override {
         if (chr == '\n') {
             m_column = 0;
             m_os << chr;
@@ -796,7 +792,7 @@ class EmitVPrefixedFormatter final : public V3OutFormatter {
         }
     }
 
-    virtual void putsOutput(const char* strg) override {
+    void putsOutput(const char* strg) override {
         for (const char* cp = strg; *cp; cp++) putcOutput(*cp);
     }
 
@@ -812,7 +808,7 @@ public:
         m_prefixFl = v3Global.rootp()->fileline();  // NETLIST's fileline instead of nullptr to
                                                     // avoid nullptr checks
     }
-    virtual ~EmitVPrefixedFormatter() override {
+    ~EmitVPrefixedFormatter() override {
         if (m_column) puts("\n");
     }
 };
@@ -822,13 +818,13 @@ class EmitVPrefixedVisitor final : public EmitVBaseVisitor {
     EmitVPrefixedFormatter m_formatter;  // Special verilog formatter (Way down the
                                          // inheritance is another unused V3OutFormatter)
     // METHODS
-    virtual void putsNoTracking(const string& str) override { m_formatter.putsNoTracking(str); }
-    virtual void puts(const string& str) override { m_formatter.puts(str); }
+    void putsNoTracking(const string& str) override { m_formatter.putsNoTracking(str); }
+    void puts(const string& str) override { m_formatter.puts(str); }
     // We don't use m_formatter's putbs because the tokens will change filelines
     // and insert returns at the proper locations
-    virtual void putbs(const string& str) override { m_formatter.puts(str); }
-    virtual void putfs(AstNode* nodep, const string& str) override { putfsqs(nodep, str, false); }
-    virtual void putqs(AstNode* nodep, const string& str) override { putfsqs(nodep, str, true); }
+    void putbs(const string& str) override { m_formatter.puts(str); }
+    void putfs(AstNode* nodep, const string& str) override { putfsqs(nodep, str, false); }
+    void putqs(AstNode* nodep, const string& str) override { putfsqs(nodep, str, true); }
     void putfsqs(AstNode* nodep, const string& str, bool quiet) {
         if (m_formatter.prefixFl() != nodep->fileline()) {
             m_formatter.prefixFl(nodep->fileline());
@@ -846,7 +842,7 @@ public:
         if (user3mark) VNUser3InUse::check();
         iterate(const_cast<AstNode*>(nodep));
     }
-    virtual ~EmitVPrefixedVisitor() override = default;
+    ~EmitVPrefixedVisitor() override = default;
 };
 
 //######################################################################

src/V3EmitXml.cpp

@@ -101,11 +101,11 @@ class EmitXmlFileVisitor final : public VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         outputTag(nodep, "contassign");  // IEEE: vpiContAssign
         outputChildrenEnd(nodep, "contassign");
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         outputTag(nodep, "instance");  // IEEE: vpiInstance
         puts(" defName=");
         putsQuoted(nodep->modName());  // IEEE vpiDefName
@@ -113,7 +113,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
         putsQuoted(nodep->origName());
         outputChildrenEnd(nodep, "instance");
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         outputTag(nodep, "if");
         puts(">\n");
         iterateAndNextNull(nodep->op1p());
@@ -127,7 +127,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
         }
         puts("</if>\n");
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         outputTag(nodep, "while");
         puts(">\n");
         puts("<begin>\n");
@@ -150,19 +150,19 @@ class EmitXmlFileVisitor final : public VNVisitor {
         }
         puts("</while>\n");
     }
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         puts("<netlist>\n");
         iterateChildren(nodep);
         puts("</netlist>\n");
     }
-    virtual void visit(AstConstPool* nodep) override {
+    void visit(AstConstPool* nodep) override {
         if (!v3Global.opt.xmlOnly()) {
             puts("<constpool>\n");
             iterateChildren(nodep);
             puts("</constpool>\n");
         }
     }
-    virtual void visit(AstInitArray* nodep) override {
+    void visit(AstInitArray* nodep) override {
         puts("<initarray>\n");
         const auto& mapr = nodep->map();
         for (const auto& itr : mapr) {
@@ -174,7 +174,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
         }
         puts("</initarray>\n");
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         outputTag(nodep, "");
         puts(" origName=");
         putsQuoted(nodep->origName());
@@ -184,7 +184,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
         if (nodep->modPublic()) puts(" public=\"true\"");
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         const VVarType typ = nodep->varType();
         const string kw = nodep->verilogKwd();
         const string vt = nodep->dtypep()->name();
@@ -222,7 +222,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
         if (nodep->attrSFormat()) puts(" sformat=\"true\"");
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         // What we call a pin in verilator is a port in the IEEE spec.
         outputTag(nodep, "port");  // IEEE: vpiPort
         if (nodep->modVarp()->isIO()) {
@@ -232,12 +232,12 @@ class EmitXmlFileVisitor final : public VNVisitor {
         // Children includes vpiHighConn and vpiLowConn; we don't support port bits (yet?)
         outputChildrenEnd(nodep, "port");
     }
-    virtual void visit(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         outputTag(nodep, "");
         puts(" edgeType=\"" + cvtToStr(nodep->edgeType().ascii()) + "\"");  // IEEE vpiTopModule
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstModportVarRef* nodep) override {
+    void visit(AstModportVarRef* nodep) override {
         // Dump direction for Modport references
         const string kw = nodep->direction().xmlKwd();
         outputTag(nodep, "");
@@ -245,13 +245,13 @@ class EmitXmlFileVisitor final : public VNVisitor {
         putsQuoted(kw);
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         outputTag(nodep, "");
         puts(" dotted=");
         putsQuoted(nodep->dotted());
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         outputTag(nodep, "");
         puts(" func=");
         putsQuoted(nodep->funcp()->name());
@@ -259,7 +259,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
     }
 
     // Data types
-    virtual void visit(AstBasicDType* nodep) override {
+    void visit(AstBasicDType* nodep) override {
         outputTag(nodep, "basicdtype");
         if (nodep->isRanged()) {
             puts(" left=\"" + cvtToStr(nodep->left()) + "\"");
@@ -268,7 +268,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
         if (nodep->isSigned()) { puts(" signed=\"true\""); }
         puts("/>\n");
     }
-    virtual void visit(AstIfaceRefDType* nodep) override {
+    void visit(AstIfaceRefDType* nodep) override {
         string mpn;
         outputTag(nodep, "");
         if (nodep->isModport()) mpn = nodep->modportName();
@@ -276,19 +276,19 @@ class EmitXmlFileVisitor final : public VNVisitor {
         putsQuoted(mpn);
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisplay* nodep) override {
         outputTag(nodep, "");
         puts(" displaytype=");
         putsQuoted(nodep->verilogKwd());
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstElabDisplay* nodep) override {
+    void visit(AstElabDisplay* nodep) override {
         outputTag(nodep, "");
         puts(" displaytype=");
         putsQuoted(nodep->verilogKwd());
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstExtend* nodep) override {
+    void visit(AstExtend* nodep) override {
         outputTag(nodep, "");
         puts(" width=");
         putsQuoted(cvtToStr(nodep->width()));
@@ -296,7 +296,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
         putsQuoted(cvtToStr(nodep->lhsp()->widthMinV()));
         outputChildrenEnd(nodep, "");
     }
-    virtual void visit(AstExtendS* nodep) override {
+    void visit(AstExtendS* nodep) override {
         outputTag(nodep, "");
         puts(" width=");
         putsQuoted(cvtToStr(nodep->width()));
@@ -306,7 +306,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
     }
 
     // Default
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         outputTag(nodep, "");
         outputChildrenEnd(nodep, "");
     }
@@ -316,7 +316,7 @@ public:
         : m_ofp{ofp} {
         iterate(nodep);
     }
-    virtual ~EmitXmlFileVisitor() override = default;
+    ~EmitXmlFileVisitor() override = default;
 };
 
 //######################################################################
@@ -333,11 +333,11 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Children are iterated backwards to ensure correct compilation order
         iterateChildrenBackwards(nodep);
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // Only list modules and interfaces
         // Assumes modules and interfaces list is already sorted level wise
         if (!nodep->dead() && (VN_IS(nodep, Module) || VN_IS(nodep, Iface))
@@ -346,7 +346,7 @@ private:
         }
     }
     //-----
-    virtual void visit(AstNode*) override {
+    void visit(AstNode*) override {
         // All modules are present at root so no need to iterate on children
     }
 
@@ -364,7 +364,7 @@ public:
         }
         m_os << "</module_files>\n";
     }
-    virtual ~ModuleFilesXmlVisitor() override = default;
+    ~ModuleFilesXmlVisitor() override = default;
 };
 
 //######################################################################
@@ -381,9 +381,9 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstConstPool*) override {}
+    void visit(AstConstPool*) override {}
 
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         if (nodep->level() >= 0
             && nodep->level() <= 2) {  // ==2 because we don't add wrapper when in XML mode
             m_os << "<cells>\n";
@@ -402,7 +402,7 @@ private:
             m_os << "</cells>\n";
         }
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         if (nodep->modp()->dead()) return;
         if (!m_hasChildren) m_os << ">\n";
         m_os << "<cell " << nodep->fileline()->xmlDetailedLocation() << " name=\"" << nodep->name()
@@ -422,7 +422,7 @@ private:
         m_hasChildren = true;
     }
     //-----
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -431,7 +431,7 @@ public:
         // Operate on whole netlist
         nodep->accept(*this);
     }
-    virtual ~HierCellsXmlVisitor() override = default;
+    ~HierCellsXmlVisitor() override = default;
 };
 
 //######################################################################

src/V3Expand.cpp

@@ -313,7 +313,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstExtend* nodep) override {
+    void visit(AstExtend* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         iterateChildren(nodep);
         if (nodep->isWide()) {
@@ -339,7 +339,7 @@ private:
         }
     }
 
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         iterateChildren(nodep);
         // Remember, Sel's may have non-integer rhs, so need to optimize for that!
@@ -628,7 +628,7 @@ private:
         }
     }
 
-    virtual void visit(AstConcat* nodep) override {
+    void visit(AstConcat* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         iterateChildren(nodep);
         if (nodep->isWide()) {
@@ -665,7 +665,7 @@ private:
         return true;
     }
 
-    virtual void visit(AstReplicate* nodep) override {
+    void visit(AstReplicate* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         iterateChildren(nodep);
         if (nodep->isWide()) {
@@ -750,10 +750,10 @@ private:
             VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
         }
     }
-    virtual void visit(AstEq* nodep) override { visitEqNeq(nodep); }
-    virtual void visit(AstNeq* nodep) override { visitEqNeq(nodep); }
+    void visit(AstEq* nodep) override { visitEqNeq(nodep); }
+    void visit(AstNeq* nodep) override { visitEqNeq(nodep); }
 
-    virtual void visit(AstRedOr* nodep) override {
+    void visit(AstRedOr* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         iterateChildren(nodep);
         FileLine* const fl = nodep->fileline();
@@ -775,7 +775,7 @@ private:
             VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
         }
     }
-    virtual void visit(AstRedAnd* nodep) override {
+    void visit(AstRedAnd* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         iterateChildren(nodep);
         FileLine* const fl = nodep->fileline();
@@ -805,7 +805,7 @@ private:
             VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
         }
     }
-    virtual void visit(AstRedXor* nodep) override {
+    void visit(AstRedXor* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         iterateChildren(nodep);
         if (nodep->lhsp()->isWide()) {
@@ -825,7 +825,7 @@ private:
         // which the inlined function does nicely.
     }
 
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         if (!nodep->isStatement()) {
             iterateChildren(nodep);
@@ -835,7 +835,7 @@ private:
         iterateChildren(nodep);
         m_stmtp = nullptr;
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         m_stmtp = nodep;
         iterateChildren(nodep);
@@ -876,13 +876,13 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstVar*) override {}  // Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't hit varrefs under vars
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit ExpandVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~ExpandVisitor() override {
+    ~ExpandVisitor() override {
         V3Stats::addStat("Optimizations, expand wides", m_statWides);
         V3Stats::addStat("Optimizations, expand wide words", m_statWideWords);
         V3Stats::addStat("Optimizations, expand limited", m_statWideLimited);

src/V3File.h

@@ -206,7 +206,7 @@ public:
     V3OutFile(V3OutFile&&) = delete;
     V3OutFile& operator=(V3OutFile&&) = delete;
 
-    virtual ~V3OutFile() override;
+    ~V3OutFile() override;
     void putsForceIncs();
 
 private:
@@ -216,11 +216,11 @@ private:
     }
 
     // CALLBACKS
-    virtual void putcOutput(char chr) override {
+    void putcOutput(char chr) override {
         m_bufferp->at(m_usedBytes++) = chr;
         if (VL_UNLIKELY(m_usedBytes >= WRITE_BUFFER_SIZE_BYTES)) writeBlock();
     }
-    virtual void putsOutput(const char* str) override {
+    void putsOutput(const char* str) override {
         std::size_t len = strlen(str);
         std::size_t availableBytes = WRITE_BUFFER_SIZE_BYTES - m_usedBytes;
         while (VL_UNLIKELY(len >= availableBytes)) {
@@ -246,7 +246,7 @@ public:
         : V3OutFile{filename, V3OutFormatter::LA_C} {
         resetPrivate();
     }
-    virtual ~V3OutCFile() override = default;
+    ~V3OutCFile() override = default;
     virtual void putsHeader() { puts("// Verilated -*- C++ -*-\n"); }
     virtual void putsIntTopInclude() { putsForceIncs(); }
     virtual void putsGuard();
@@ -270,9 +270,9 @@ class V3OutScFile final : public V3OutCFile {
 public:
     explicit V3OutScFile(const string& filename)
         : V3OutCFile{filename} {}
-    virtual ~V3OutScFile() override = default;
-    virtual void putsHeader() override { puts("// Verilated -*- SystemC -*-\n"); }
-    virtual void putsIntTopInclude() override {
+    ~V3OutScFile() override = default;
+    void putsHeader() override { puts("// Verilated -*- SystemC -*-\n"); }
+    void putsIntTopInclude() override {
         putsForceIncs();
         puts("#include \"systemc.h\"\n");
         puts("#include \"verilated_sc.h\"\n");
@@ -283,7 +283,7 @@ class V3OutVFile final : public V3OutFile {
 public:
     explicit V3OutVFile(const string& filename)
         : V3OutFile{filename, V3OutFormatter::LA_VERILOG} {}
-    virtual ~V3OutVFile() override = default;
+    ~V3OutVFile() override = default;
     virtual void putsHeader() { puts("// Verilated -*- Verilog -*-\n"); }
 };
 
@@ -293,7 +293,7 @@ public:
         : V3OutFile{filename, V3OutFormatter::LA_XML} {
         blockIndent(2);
     }
-    virtual ~V3OutXmlFile() override = default;
+    ~V3OutXmlFile() override = default;
     virtual void putsHeader() { puts("<?xml version=\"1.0\" ?>\n"); }
 };
 
@@ -301,7 +301,7 @@ class V3OutMkFile final : public V3OutFile {
 public:
     explicit V3OutMkFile(const string& filename)
         : V3OutFile{filename, V3OutFormatter::LA_MK} {}
-    virtual ~V3OutMkFile() override = default;
+    ~V3OutMkFile() override = default;
     virtual void putsHeader() { puts("# Verilated -*- Makefile -*-\n"); }
     // No automatic indentation yet.
     void puts(const char* strg) { putsNoTracking(strg); }

src/V3Gate.cpp

@@ -79,9 +79,9 @@ public:
     GateEitherVertex(V3Graph* graphp, AstScope* scopep)
         : V3GraphVertex{graphp}
         , m_scopep{scopep} {}
-    virtual ~GateEitherVertex() override = default;
+    ~GateEitherVertex() override = default;
     // ACCESSORS
-    virtual string dotStyle() const override { return m_consumed ? "" : "dotted"; }
+    string dotStyle() const override { return m_consumed ? "" : "dotted"; }
     AstScope* scopep() const { return m_scopep; }
     bool reducible() const { return m_reducible; }
     bool dedupable() const { return m_dedupable; }
@@ -137,11 +137,11 @@ public:
     GateVarVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
         : GateEitherVertex{graphp, scopep}
         , m_varScp{varScp} {}
-    virtual ~GateVarVertex() override = default;
+    ~GateVarVertex() override = default;
     // ACCESSORS
     AstVarScope* varScp() const { return m_varScp; }
-    virtual string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
-    virtual string dotColor() const override { return "blue"; }
+    string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
+    string dotColor() const override { return "blue"; }
     bool isTop() const { return m_isTop; }
     void setIsTop() { m_isTop = true; }
     bool isClock() const { return m_isClock; }
@@ -162,7 +162,7 @@ public:
             setIsClock();
         }
     }
-    virtual VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
+    VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
         return v.visit(this, vu);
     }
 };
@@ -178,17 +178,15 @@ public:
         , m_nodep{nodep}
         , m_activep{activep}
         , m_slow{slow} {}
-    virtual ~GateLogicVertex() override = default;
+    ~GateLogicVertex() override = default;
     // ACCESSORS
-    virtual string name() const override {
-        return (cvtToHex(m_nodep) + "@" + scopep()->prettyName());
-    }
-    virtual string dotColor() const override { return "purple"; }
-    virtual FileLine* fileline() const override { return nodep()->fileline(); }
+    string name() const override { return (cvtToHex(m_nodep) + "@" + scopep()->prettyName()); }
+    string dotColor() const override { return "purple"; }
+    FileLine* fileline() const override { return nodep()->fileline(); }
     AstNode* nodep() const { return m_nodep; }
     AstActive* activep() const { return m_activep; }
     bool slow() const { return m_slow; }
-    virtual VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
+    VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
         return v.visit(this, vu);
     }
 };
@@ -217,7 +215,7 @@ private:
         }
     }
     // VISITORS
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         ++m_ops;
         iterateChildren(nodep);
         // We only allow a LHS ref for the var being set, and a RHS ref for
@@ -243,7 +241,7 @@ private:
             m_rhsVarRefs.push_back(nodep);
         }
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         m_substTreep = nodep->rhsp();
         if (!VN_IS(nodep->lhsp(), NodeVarRef)) {
             clearSimple("ASSIGN(non-VARREF)");
@@ -264,7 +262,7 @@ private:
         }
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         // *** Special iterator
         if (!m_isSimple) return;  // Fastpath
         if (++m_ops > v3Global.opt.gateStmts()) clearSimple("--gate-stmts exceeded");
@@ -294,7 +292,7 @@ public:
         }
         if (debug() >= 9 && !m_isSimple) nodep->dumpTree(cout, "    gate!Ok: ");
     }
-    virtual ~GateOkVisitor() override = default;
+    ~GateOkVisitor() override = default;
     // PUBLIC METHODS
     bool isSimple() const { return m_isSimple; }
     AstNode* substTree() const { return m_substTreep; }
@@ -413,7 +411,7 @@ private:
     void decomposeClkVectors();
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         iterateChildren(nodep);
         // if (debug() > 6) m_graph.dump();
         if (debug() > 6) m_graph.dumpDotFilePrefixed("gate_pre");
@@ -445,7 +443,7 @@ private:
         // Rewrite assignments
         consumedMove();
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
@@ -453,14 +451,14 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UINFO(4, " SCOPE " << nodep << endl);
         m_scopep = nodep;
         m_logicVertexp = nullptr;
         iterateChildren(nodep);
         m_scopep = nullptr;
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         // Create required blocks and add to module
         UINFO(4, "  BLOCK  " << nodep << endl);
         m_activeReducible = !(nodep->hasClocked());  // Seq logic outputs aren't reducible
@@ -471,7 +469,7 @@ private:
         m_activep = nullptr;
         m_activeReducible = true;
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         if (m_scopep) {
             UASSERT_OBJ(m_logicVertexp, nodep, "Var ref not under a logic block");
             AstVarScope* const varscp = nodep->varScopep();
@@ -499,17 +497,17 @@ private:
             }
         }
     }
-    virtual void visit(AstAlwaysPublic* nodep) override {
+    void visit(AstAlwaysPublic* nodep) override {
         VL_RESTORER(m_inSlow);
         {
             m_inSlow = true;
             iterateNewStmt(nodep, "AlwaysPublic", nullptr);
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         iterateNewStmt(nodep, "User C Function", "User C Function");
     }
-    virtual void visit(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         m_inSenItem = true;
         if (m_logicVertexp) {  // Already under logic; presumably a SenGate
             iterateChildren(nodep);
@@ -518,7 +516,7 @@ private:
         }
         m_inSenItem = false;
     }
-    virtual void visit(AstNodeProcedure* nodep) override {
+    void visit(AstNodeProcedure* nodep) override {
         VL_RESTORER(m_inSlow);
         {
             m_inSlow = VN_IS(nodep, Initial) || VN_IS(nodep, Final);
@@ -526,23 +524,23 @@ private:
                            nullptr);
         }
     }
-    virtual void visit(AstAssignAlias* nodep) override {  //
+    void visit(AstAssignAlias* nodep) override {  //
         iterateNewStmt(nodep, nullptr, nullptr);
     }
-    virtual void visit(AstAssignW* nodep) override {  //
+    void visit(AstAssignW* nodep) override {  //
         iterateNewStmt(nodep, nullptr, nullptr);
     }
-    virtual void visit(AstCoverToggle* nodep) override {
+    void visit(AstCoverToggle* nodep) override {
         iterateNewStmt(nodep, "CoverToggle", "CoverToggle");
     }
-    virtual void visit(AstTraceDecl* nodep) override {
+    void visit(AstTraceDecl* nodep) override {
         VL_RESTORER(m_inSlow);
         {
             m_inSlow = true;
             iterateNewStmt(nodep, "Tracing", "Tracing");
         }
     }
-    virtual void visit(AstConcat* nodep) override {
+    void visit(AstConcat* nodep) override {
         UASSERT_OBJ(!(VN_IS(nodep->backp(), NodeAssign)
                       && VN_AS(nodep->backp(), NodeAssign)->lhsp() == nodep),
                     nodep, "Concat on LHS of assignment; V3Const should have deleted it");
@@ -550,7 +548,7 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         if (nodep->isOutputter() && m_logicVertexp) m_logicVertexp->setConsumed("outputter");
     }
@@ -558,7 +556,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit GateVisitor(AstNode* nodep) { iterate(nodep); }
-    virtual ~GateVisitor() override {
+    ~GateVisitor() override {
         V3Stats::addStat("Optimizations, Gate sigs deleted", m_statSigs);
         V3Stats::addStat("Optimizations, Gate inputs replaced", m_statRefs);
         V3Stats::addStat("Optimizations, Gate sigs deduped", m_statDedupLogic);
@@ -810,7 +808,7 @@ private:
 
 public:
     GateDedupeHash() = default;
-    virtual ~GateDedupeHash() override {
+    ~GateDedupeHash() override {
         if (v3Global.opt.debugCheck()) check();
     }
 
@@ -836,7 +834,7 @@ public:
     }
 
     // Callback from V3DupFinder::findDuplicate
-    virtual bool isSame(AstNode* node1p, AstNode* node2p) override {
+    bool isSame(AstNode* node1p, AstNode* node2p) override {
         // Assignment may have been hashReplaced, if so consider non-match (effectively removed)
         if (isReplaced(node1p) || isReplaced(node2p)) {
             // UINFO(9, "isSame hit on replaced "<<(void*)node1p<<" "<<(void*)node2p<<endl);
@@ -908,7 +906,7 @@ private:
     bool m_dedupable = true;  // Determined the assign to be dedupable
 
     // VISITORS
-    virtual void visit(AstNodeAssign* assignp) override {
+    void visit(AstNodeAssign* assignp) override {
         if (m_dedupable) {
             // I think we could safely dedupe an always block with multiple
             // non-blocking statements, but erring on side of caution here
@@ -919,7 +917,7 @@ private:
             }
         }
     }
-    virtual void visit(AstAlways* alwaysp) override {
+    void visit(AstAlways* alwaysp) override {
         if (m_dedupable) {
             if (!m_always) {
                 m_always = true;
@@ -933,7 +931,7 @@ private:
     //  always @(...)
     //    if (...)
     //       foo = ...; // or foo <= ...;
-    virtual void visit(AstNodeIf* ifp) override {
+    void visit(AstNodeIf* ifp) override {
         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
@@ -945,16 +943,16 @@ private:
         }
     }
 
-    virtual void visit(AstComment*) override {}  // NOP
+    void visit(AstComment*) override {}  // NOP
     //--------------------
-    virtual void visit(AstNode*) override {  //
+    void visit(AstNode*) override {  //
         m_dedupable = false;
     }
 
 public:
     // CONSTRUCTORS
     GateDedupeVarVisitor() = default;
-    virtual ~GateDedupeVarVisitor() override = default;
+    ~GateDedupeVarVisitor() override = default;
     // PUBLIC METHODS
     AstNodeVarRef* findDupe(AstNode* nodep, AstVarScope* consumerVarScopep, AstActive* activep) {
         m_assignp = nullptr;
@@ -1043,7 +1041,7 @@ private:
     GateDedupeVarVisitor m_varVisitor;  // Looks for a dupe of the logic
     int m_depth = 0;  // Iteration depth
 
-    virtual VNUser visit(GateVarVertex* vvertexp, VNUser) override {
+    VNUser visit(GateVarVertex* vvertexp, VNUser) override {
         // Check that we haven't been here before
         if (m_depth > GATE_DEDUP_MAX_DEPTH)
             return VNUser{0};  // Break loops; before user2 set so hit this vertex later
@@ -1105,7 +1103,7 @@ private:
 
     // Given iterated logic, starting at vu which was consumer's GateVarVertex
     // Returns a varref that has the same logic input; or nullptr if none
-    virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override {
+    VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override {
         lvertexp->iterateInEdges(*this);
 
         const GateVarVertex* const consumerVvertexpp
@@ -1185,7 +1183,7 @@ private:
         }
     }
 
-    virtual VNUser visit(GateVarVertex* vvertexp, VNUser) override {
+    VNUser visit(GateVarVertex* vvertexp, VNUser) override {
         for (V3GraphEdge* edgep = vvertexp->inBeginp(); edgep;) {
             V3GraphEdge* oldedgep = edgep;
             edgep = edgep->inNextp();  // for recursive since the edge could be deleted
@@ -1259,7 +1257,7 @@ private:
         }
         return VNUser{0};
     }
-    virtual VNUser visit(GateLogicVertex*, VNUser) override {  //
+    VNUser visit(GateLogicVertex*, VNUser) override {  //
         return VNUser{0};
     }
 
@@ -1297,7 +1295,7 @@ private:
     bool m_found = false;  // Offset found
 
     // VISITORS
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         UINFO(9, "CLK DECOMP Concat search var (off = " << m_offset << ") - " << nodep << endl);
         if (nodep->varScopep() == m_vscp && !nodep->user2() && !m_found) {
             // A concatenation may use the same var multiple times
@@ -1309,18 +1307,18 @@ private:
         }
         m_offset += nodep->dtypep()->width();
     }
-    virtual void visit(AstConcat* nodep) override {
+    void visit(AstConcat* nodep) override {
         UINFO(9, "CLK DECOMP Concat search (off = " << m_offset << ") - " << nodep << endl);
         iterate(nodep->rhsp());
         iterate(nodep->lhsp());
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     GateConcatVisitor() = default;
-    virtual ~GateConcatVisitor() override = default;
+    ~GateConcatVisitor() override = default;
     // PUBLIC METHODS
     bool concatOffset(AstConcat* concatp, AstVarScope* vscp, int& offsetr) {
         m_vscp = vscp;
@@ -1360,7 +1358,7 @@ private:
     int m_total_seen_clk_vectors = 0;
     int m_total_decomposed_clk_vectors = 0;
 
-    virtual VNUser visit(GateVarVertex* vvertexp, VNUser vu) override {
+    VNUser visit(GateVarVertex* vvertexp, VNUser vu) override {
         // Check that we haven't been here before
         AstVarScope* const vsp = vvertexp->varScp();
         if (vsp->user2SetOnce()) return VNUser{0};
@@ -1377,7 +1375,7 @@ private:
         return VNUser{0};  // Unused
     }
 
-    virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override {
+    VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override {
         const GateClkDecompState* const currState = reinterpret_cast<GateClkDecompState*>(vu.c());
         int clk_offset = currState->m_offset;
         if (const AstAssignW* const assignp = VN_CAST(lvertexp->nodep(), AssignW)) {
@@ -1444,7 +1442,7 @@ private:
 public:
     explicit GateClkDecompGraphVisitor(V3Graph* graphp)
         : GateGraphBaseVisitor{graphp} {}
-    virtual ~GateClkDecompGraphVisitor() override {
+    ~GateClkDecompGraphVisitor() override {
         V3Stats::addStat("Optimizations, Clocker seen vectors", m_total_seen_clk_vectors);
         V3Stats::addStat("Optimizations, Clocker decomposed vectors",
                          m_total_decomposed_clk_vectors);

src/V3GenClk.cpp

@@ -90,7 +90,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // Consumption/generation of a variable,
         if (m_activep && !nodep->user3SetOnce()) {
             AstVarScope* const vscp = nodep->varScopep();
@@ -105,14 +105,14 @@ private:
             }
         }
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         m_activep = nodep;
         iterate(nodep->sensesp());
         m_activep = nullptr;
     }
 
     //-----
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -120,7 +120,7 @@ public:
         : m_topModp{topModp} {
         iterate(nodep);
     }
-    virtual ~GenClkRenameVisitor() override = default;
+    ~GenClkRenameVisitor() override = default;
 };
 
 //######################################################################
@@ -139,7 +139,7 @@ private:
     AstNodeModule* m_topModp = nullptr;  // Top module
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep) override {
+    void visit(AstTopScope* nodep) override {
         {
             const VNUser1InUse user1InUse;
             iterateChildren(nodep);
@@ -148,14 +148,14 @@ private:
         // See rename, it does some AstNode::userClearTree()'s
         GenClkRenameVisitor{nodep, m_topModp};
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // Only track the top scopes, not lower level functions
         if (nodep->isTop()) {
             m_topModp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         iterateChildren(nodep);
         if (!nodep->funcp()->entryPoint()) {
             // Enter the function and trace it
@@ -163,7 +163,7 @@ private:
             iterate(nodep->funcp());
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (!m_tracingCall && !nodep->entryPoint()) {
             // Only consider logic within a CFunc when looking
             // at the call to it, and not when scanning whatever
@@ -175,7 +175,7 @@ private:
     }
     //----
 
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // Consumption/generation of a variable,
         AstVarScope* const vscp = nodep->varScopep();
         UASSERT_OBJ(vscp, nodep, "Scope not assigned");
@@ -190,13 +190,13 @@ private:
             vscp->circular(true);
         }
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         // UINFO(8, "ASS " << nodep << endl);
         m_assignp = nodep;
         iterateChildren(nodep);
         m_assignp = nullptr;
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         UINFO(8, "ACTIVE " << nodep << endl);
         m_activep = nodep;
         UASSERT_OBJ(nodep->sensesp(), nodep, "Unlinked");
@@ -206,13 +206,13 @@ private:
     }
 
     //-----
-    virtual void visit(AstVar*) override {}  // Don't want varrefs under it
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't want varrefs under it
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit GenClkReadVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~GenClkReadVisitor() override = default;
+    ~GenClkReadVisitor() override = default;
 };
 
 //######################################################################

src/V3GraphAcyc.cpp

@@ -42,13 +42,13 @@ public:
     GraphAcycVertex(V3Graph* graphp, V3GraphVertex* origVertexp)
         : V3GraphVertex{graphp}
         , m_origVertexp{origVertexp} {}
-    virtual ~GraphAcycVertex() override = default;
+    ~GraphAcycVertex() override = default;
     V3GraphVertex* origVertexp() const { return m_origVertexp; }
     void setDelete() { m_deleted = true; }
     bool isDelete() const { return m_deleted; }
-    virtual string name() const override { return m_origVertexp->name(); }
-    virtual string dotColor() const override { return m_origVertexp->dotColor(); }
-    virtual FileLine* fileline() const override { return m_origVertexp->fileline(); }
+    string name() const override { return m_origVertexp->name(); }
+    string dotColor() const override { return m_origVertexp->dotColor(); }
+    FileLine* fileline() const override { return m_origVertexp->fileline(); }
 };
 
 //--------------------------------------------------------------------
@@ -67,11 +67,9 @@ public:
     GraphAcycEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight,
                   bool cutable = false)
         : V3GraphEdge{graphp, fromp, top, weight, cutable} {}
-    virtual ~GraphAcycEdge() override = default;
+    ~GraphAcycEdge() override = default;
     // yellow=we might still cut it, else oldEdge: yellowGreen=made uncutable, red=uncutable
-    virtual string dotColor() const override {
-        return (cutable() ? "yellow" : origEdgep()->dotColor());
-    }
+    string dotColor() const override { return (cutable() ? "yellow" : origEdgep()->dotColor()); }
 };
 
 //--------------------------------------------------------------------

src/V3GraphTest.cpp

@@ -56,18 +56,18 @@ public:
     V3GraphTestVertex(V3Graph* graphp, const string& name)
         : V3GraphVertex{graphp}
         , m_name{name} {}
-    virtual ~V3GraphTestVertex() override = default;
+    ~V3GraphTestVertex() override = default;
     // ACCESSORS
-    virtual string name() const override { return m_name; }
+    string name() const override { return m_name; }
 };
 
 class V3GraphTestVarVertex final : public V3GraphTestVertex {
 public:
     V3GraphTestVarVertex(V3Graph* graphp, const string& name)
         : V3GraphTestVertex{graphp, name} {}
-    virtual ~V3GraphTestVarVertex() override = default;
+    ~V3GraphTestVarVertex() override = default;
     // ACCESSORS
-    virtual string dotColor() const override { return "blue"; }
+    string dotColor() const override { return "blue"; }
 };
 
 //######################################################################
@@ -76,8 +76,8 @@ public:
 
 class V3GraphTestStrong final : public V3GraphTest {
 public:
-    virtual string name() override { return "strong"; }
-    virtual void runTest() override {
+    string name() override { return "strong"; }
+    void runTest() override {
         V3Graph* gp = &m_graph;
         // Verify we break edges at a good point
         // A simple alg would make 3 breaks, below only requires b->i to break
@@ -114,8 +114,8 @@ public:
 
 class V3GraphTestAcyc final : public V3GraphTest {
 public:
-    virtual string name() override { return "acyc"; }
-    virtual void runTest() override {
+    string name() override { return "acyc"; }
+    void runTest() override {
         V3Graph* gp = &m_graph;
         // Verify we break edges at a good point
         // A simple alg would make 3 breaks, below only requires b->i to break
@@ -142,8 +142,8 @@ public:
 
 class V3GraphTestVars final : public V3GraphTest {
 public:
-    virtual string name() override { return "vars"; }
-    virtual void runTest() override {
+    string name() override { return "vars"; }
+    void runTest() override {
         V3Graph* gp = &m_graph;
 
         V3GraphTestVertex* clk = new V3GraphTestVarVertex(gp, "$clk");
@@ -268,8 +268,8 @@ class V3GraphTestImport final : public V3GraphTest {
 #endif
 
 public:
-    virtual string name() override { return "import"; }
-    virtual void runTest() override {
+    string name() override { return "import"; }
+    void runTest() override {
         V3Graph* const gp = &m_graph;
         dotImport();
         dump();

src/V3Hasher.cpp

@@ -80,7 +80,7 @@ private:
     //------------------------------------------------------------
     // AstNode - Warns to help find missing cases
 
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
 #if VL_DEBUG
         UINFO(0, "%Warning: Hashing node as AstNode: " << nodep << endl);
 #endif
@@ -89,93 +89,93 @@ private:
 
     //------------------------------------------------------------
     // AstNodeDType
-    virtual void visit(AstNodeArrayDType* nodep) override {
+    void visit(AstNodeArrayDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
             iterateNull(nodep->virtRefDTypep());
             m_hash += nodep->left();
             m_hash += nodep->right();
         });
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) override {
+    void visit(AstNodeUOrStructDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, false, [=]() {  //
             m_hash += nodep->uniqueNum();
         });
     }
-    virtual void visit(AstParamTypeDType* nodep) override {
+    void visit(AstParamTypeDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             m_hash += nodep->varType();
         });
     }
-    virtual void visit(AstMemberDType* nodep) override {
+    void visit(AstMemberDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstDefImplicitDType* nodep) override {
+    void visit(AstDefImplicitDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->uniqueNum();
         });
     }
-    virtual void visit(AstAssocArrayDType* nodep) override {
+    void visit(AstAssocArrayDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
             iterateNull(nodep->virtRefDTypep());
             iterateNull(nodep->virtRefDType2p());
         });
     }
-    virtual void visit(AstDynArrayDType* nodep) override {
+    void visit(AstDynArrayDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->virtRefDTypep());
         });
     }
-    virtual void visit(AstUnsizedArrayDType* nodep) override {
+    void visit(AstUnsizedArrayDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->virtRefDTypep());
         });
     }
-    virtual void visit(AstWildcardArrayDType* nodep) override {
+    void visit(AstWildcardArrayDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->virtRefDTypep());
         });
     }
-    virtual void visit(AstBasicDType* nodep) override {
+    void visit(AstBasicDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
             m_hash += nodep->keyword();
             m_hash += nodep->nrange().left();
             m_hash += nodep->nrange().right();
         });
     }
-    virtual void visit(AstConstDType* nodep) override {
+    void visit(AstConstDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->virtRefDTypep());
         });
     }
-    virtual void visit(AstClassRefDType* nodep) override {
+    void visit(AstClassRefDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->classp());
         });
     }
-    virtual void visit(AstIfaceRefDType* nodep) override {
+    void visit(AstIfaceRefDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->cellp());
         });
     }
-    virtual void visit(AstQueueDType* nodep) override {
+    void visit(AstQueueDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->virtRefDTypep());
         });
     }
-    virtual void visit(AstRefDType* nodep) override {
+    void visit(AstRefDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             iterateNull(nodep->typedefp());
             iterateNull(nodep->refDTypep());
         });
     }
-    virtual void visit(AstVoidDType* nodep) override {
+    void visit(AstVoidDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstEnumDType* nodep) override {
+    void visit(AstEnumDType* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, false, [=]() {  //
             m_hash += nodep->uniqueNum();
         });
@@ -183,23 +183,23 @@ private:
 
     //------------------------------------------------------------
     // AstNodeMath
-    virtual void visit(AstNodeMath* nodep) override {
+    void visit(AstNodeMath* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->num().toHash();
         });
     }
-    virtual void visit(AstNullCheck* nodep) override {
+    void visit(AstNullCheck* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstCCast* nodep) override {
+    void visit(AstCCast* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->size();
         });
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             if (nodep->varScopep()) {
                 iterateNull(nodep->varScopep());
@@ -209,28 +209,28 @@ private:
             }
         });
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             iterateNull(nodep->varp());
             m_hash += nodep->dotted();
         });
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstFScanF* nodep) override {
+    void visit(AstFScanF* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->text();
         });
     }
-    virtual void visit(AstSScanF* nodep) override {
+    void visit(AstSScanF* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->text();
         });
     }
-    virtual void visit(AstAddrOfCFunc* nodep) override {
+    void visit(AstAddrOfCFunc* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->funcp());
         });
@@ -238,56 +238,56 @@ private:
 
     //------------------------------------------------------------
     // AstNodeStmt
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstNodeText* nodep) override {
+    void visit(AstNodeText* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->text();
         });
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->funcp());
         });
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
             iterateNull(nodep->taskp());
             iterateNull(nodep->classOrPackagep());
         });
     }
-    virtual void visit(AstCMethodHard* nodep) override {
+    void visit(AstCMethodHard* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstCoverInc* nodep) override {
+    void visit(AstCoverInc* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->declp());
         });
     }
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisplay* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->displayType();
         });
     }
-    virtual void visit(AstMonitorOff* nodep) override {
+    void visit(AstMonitorOff* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->off();
         });
     }
-    virtual void visit(AstJumpGo* nodep) override {
+    void visit(AstJumpGo* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->labelp());
         });
     }
-    virtual void visit(AstTraceInc* nodep) override {
+    void visit(AstTraceInc* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->declp());
         });
     }
-    virtual void visit(AstNodeCoverOrAssert* nodep) override {
+    void visit(AstNodeCoverOrAssert* nodep) override {
         m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
@@ -295,62 +295,62 @@ private:
 
     //------------------------------------------------------------
     // AstNode direct descendents
-    virtual void visit(AstNodeRange* nodep) override {
+    void visit(AstNodeRange* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, false, [=]() {  //
             m_hash += nodep->origName();
         });
     }
-    virtual void visit(AstNodePreSel* nodep) override {
+    void visit(AstNodePreSel* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstClassExtends* nodep) override {
+    void visit(AstClassExtends* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstSelLoopVars* nodep) override {
+    void visit(AstSelLoopVars* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstDefParam* nodep) override {
+    void visit(AstDefParam* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstArg* nodep) override {
+    void visit(AstArg* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstParseRef* nodep) override {
+    void visit(AstParseRef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->expect();
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstClassOrPackageRef* nodep) override {
+    void visit(AstClassOrPackageRef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->classOrPackageNodep());
         });
     }
-    virtual void visit(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->edgeType();
         });
     }
-    virtual void visit(AstSenTree* nodep) override {
+    void visit(AstSenTree* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->text();
         });
     }
-    virtual void visit(AstElabDisplay* nodep) override {
+    void visit(AstElabDisplay* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->displayType();
         });
     }
-    virtual void visit(AstInitItem* nodep) override {
+    void visit(AstInitItem* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstInitArray* nodep) override {
+    void visit(AstInitArray* nodep) override {
         if (const AstAssocArrayDType* const dtypep = VN_CAST(nodep->dtypep(), AssocArrayDType)) {
             if (nodep->defaultp()) {
                 m_hash
@@ -376,22 +376,22 @@ private:
             });
         }
     }
-    virtual void visit(AstPragma* nodep) override {
+    void visit(AstPragma* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->pragType();
         });
     }
-    virtual void visit(AstAttrOf* nodep) override {
+    void visit(AstAttrOf* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->attrType();
         });
     }
-    virtual void visit(AstNodeFile* nodep) override {
+    void visit(AstNodeFile* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             // We might be in a recursive function, if so on *second* call
             // here we need to break what would be an infinite loop.
@@ -402,90 +402,90 @@ private:
             m_hash += nodep->isLoose();
         });
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             m_hash += nodep->varType();
         });
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, false, [=]() {
             m_hash += nodep->name();
             iterateNull(nodep->aboveScopep());
         });
     }
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             iterateNull(nodep->varp());
             iterateNull(nodep->scopep());
         });
     }
-    virtual void visit(AstEnumItem* nodep) override {
+    void visit(AstEnumItem* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstTypedef* nodep) override {
+    void visit(AstTypedef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstTypedefFwd* nodep) override {
+    void visit(AstTypedefFwd* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             iterateNull(nodep->sensesp());
         });
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             iterateNull(nodep->modp());
         });
     }
-    virtual void visit(AstCellInline* nodep) override {
+    void visit(AstCellInline* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             iterateNull(nodep->scopep());
         });
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstModport* nodep) override {
+    void visit(AstModport* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstModportVarRef* nodep) override {
+    void visit(AstModportVarRef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             iterateNull(nodep->varp());
         });
     }
-    virtual void visit(AstModportFTaskRef* nodep) override {
+    void visit(AstModportFTaskRef* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             iterateNull(nodep->ftaskp());
         });
     }
-    virtual void visit(AstMTaskBody* nodep) override {
+    void visit(AstMTaskBody* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstNodeProcedure* nodep) override {
+    void visit(AstNodeProcedure* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
     }
-    virtual void visit(AstNodeBlock* nodep) override {
+    void visit(AstNodeBlock* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
             m_hash += nodep->name();
         });
     }
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
             m_hash += nodep->name();
             m_hash += nodep->pinNum();
@@ -504,7 +504,7 @@ public:
         iterate(const_cast<AstNode*>(nodep));
     }
     V3Hash finalHash() const { return m_hash; }
-    virtual ~HasherVisitor() override = default;
+    ~HasherVisitor() override = default;
 };
 
 //######################################################################

src/V3HierBlock.cpp

@@ -250,7 +250,7 @@ class HierBlockUsageCollectVisitor final : public VNVisitor {
     ModuleSet m_referred;  // Modules that have hier_block pragma
     V3HierBlock::GParams m_gparams;  // list of variables that is VVarType::GPARAM
 
-    virtual void visit(AstModule* nodep) override {
+    void visit(AstModule* nodep) override {
         // Don't visit twice
         if (nodep->user1SetOnce()) return;
         UINFO(5, "Checking " << nodep->prettyNameQ() << " from "
@@ -277,7 +277,7 @@ class HierBlockUsageCollectVisitor final : public VNVisitor {
         }
         m_gparams = prevGParams;
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         // Visit used module here to know that the module is hier_block or not.
         // This visitor behaves almost depth first search
         if (AstModule* const modp = VN_CAST(nodep->modp(), Module)) {
@@ -287,15 +287,15 @@ class HierBlockUsageCollectVisitor final : public VNVisitor {
         // Nothing to do for interface because hierarchical block does not exist
         // beyond interface.
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (m_modp && m_modp->hierBlock() && nodep->isIfaceRef() && !nodep->isIfaceParent()) {
             nodep->v3error("Modport cannot be used at the hierarchical block boundary");
         }
         if (nodep->isGParam() && nodep->overriddenParam()) m_gparams.push_back(nodep);
     }
 
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     HierBlockUsageCollectVisitor(V3HierBlockPlan* planp, AstNetlist* netlist)

src/V3Inline.cpp

@@ -112,7 +112,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         UASSERT_OBJ(!m_modp, nodep, "Unsupported: Nested modules");
         m_modp = nodep;
         m_allMods.push_back(nodep);
@@ -130,19 +130,19 @@ private:
         iterateChildren(nodep);
         m_modp = nullptr;
     }
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         // TODO allow inlining of modules that have classes
         // (Probably wait for new inliner scheme)
         cantInline("class", true);
         iterateChildren(nodep);
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         m_moduleState(nodep->modp()).m_cellRefs++;
         m_moduleState(m_modp).m_childCells.push_back(nodep);
         m_instances[m_modp][nodep->modp()]++;
         iterateChildren(nodep);
     }
-    virtual void visit(AstPragma* nodep) override {
+    void visit(AstPragma* nodep) override {
         if (nodep->pragType() == VPragmaType::INLINE_MODULE) {
             if (!m_modp) {
                 nodep->v3error("Inline pragma not under a module");  // LCOV_EXCL_LINE
@@ -162,28 +162,28 @@ private:
             VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
         }
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         // Remove link. V3LinkDot will reestablish it after inlining.
         nodep->varp(nullptr);
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         // Remove link. V3LinkDot will reestablish it after inlining.
         // MethodCalls not currently supported by inliner, so keep linked
         if (!nodep->classOrPackagep() && !VN_IS(nodep, MethodCall)) nodep->taskp(nullptr);
         iterateChildren(nodep);
     }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         m_modp->user4Inc();  // statement count
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         // Don't count assignments, as they'll likely flatten out
         // Still need to iterate though to nullify VarXRefs
         const int oldcnt = m_modp->user4();
         iterateChildren(nodep);
         m_modp->user4(oldcnt);
     }
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Build ModuleState, user2, and user4 for all modules.
         // Also build m_allMods and m_instances.
         iterateChildren(nodep);
@@ -226,7 +226,7 @@ private:
         }
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         if (m_modp) m_modp->user4Inc();  // Inc statement count
         iterateChildren(nodep);
     }
@@ -237,7 +237,7 @@ public:
         : m_moduleState{moduleState} {
         iterate(nodep);
     }
-    virtual ~InlineMarkVisitor() override {
+    ~InlineMarkVisitor() override {
         V3Stats::addStat("Optimizations, Inline unsupported", m_statUnsup);
     }
 };
@@ -260,7 +260,7 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstCellInline* nodep) override {
+    void visit(AstCellInline* nodep) override {
         // Inlined cell under the inline cell, need to move to avoid conflicts
         nodep->unlinkFrBack();
         m_modp->addInlinesp(nodep);
@@ -270,20 +270,20 @@ private:
         // Do CellInlines under this, but don't move them
         iterateChildren(nodep);
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         // Cell under the inline cell, need to rename to avoid conflicts
         nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
         iterateChildren(nodep);
     }
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
         iterateChildren(nodep);
     }
-    virtual void visit(AstModule* nodep) override {
+    void visit(AstModule* nodep) override {
         m_renamedInterfaces.clear();
         iterateChildren(nodep);
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (nodep->user2p()) {
             // Make an assignment, so we'll trace it properly
             // user2p is either a const or a var.
@@ -360,17 +360,17 @@ private:
         if (debug() >= 9) nodep->dumpTree(cout, "varchanged:");
         if (debug() >= 9 && nodep->valuep()) nodep->valuep()->dumpTree(cout, "varchangei:");
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         // Function under the inline cell, need to rename to avoid conflicts
         nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
         iterateChildren(nodep);
     }
-    virtual void visit(AstTypedef* nodep) override {
+    void visit(AstTypedef* nodep) override {
         // Typedef under the inline cell, need to rename to avoid conflicts
         nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
         iterateChildren(nodep);
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (nodep->varp()->user2p()  // It's being converted to an alias.
             && !nodep->varp()->user3()
             // Don't constant propagate aliases (we just made)
@@ -388,7 +388,7 @@ private:
         }
         nodep->name(nodep->varp()->name());
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         // Track what scope it was originally under so V3LinkDot can resolve it
         nodep->inlinedDots(VString::dot(m_cellp->name(), ".", nodep->inlinedDots()));
         for (string tryname = nodep->dotted(); true;) {
@@ -406,7 +406,7 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         // Track what scope it was originally under so V3LinkDot can resolve it
         nodep->inlinedDots(VString::dot(m_cellp->name(), ".", nodep->inlinedDots()));
         if (m_renamedInterfaces.count(nodep->dotted())) {
@@ -417,9 +417,9 @@ private:
     }
 
     // Not needed, as V3LinkDot doesn't care about typedefs
-    // virtual void visit(AstRefDType* nodep) override {}
+    //  void visit(AstRefDType* nodep) override {}
 
-    virtual void visit(AstScopeName* nodep) override {
+    void visit(AstScopeName* nodep) override {
         // 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
@@ -435,12 +435,12 @@ private:
         if (afterp) nodep->scopeEntrp(afterp);
         iterateChildren(nodep);
     }
-    virtual void visit(AstCoverDecl* nodep) override {
+    void visit(AstCoverDecl* nodep) override {
         // Fix path in coverage statements
         nodep->hier(VString::dot(m_cellp->prettyName(), ".", nodep->hier()));
         iterateChildren(nodep);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -449,7 +449,7 @@ public:
         , m_cellp{cellp} {
         iterate(cloneModp);
     }
-    virtual ~InlineRelinkVisitor() override = default;
+    ~InlineRelinkVisitor() override = default;
 };
 
 //######################################################################
@@ -576,13 +576,13 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Iterate modules backwards, in bottom-up order.  Required!
         iterateAndNextConstNullBackwards(nodep->modulesp());
         // Clean up AstIfaceRefDType references
         iterateChildren(nodep->typeTablep());
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         UASSERT_OBJ(!m_modp, nodep, "Unsupported: Nested modules");
         m_modp = nodep;
         // Iterate the stored cells directly to reduce traversal
@@ -592,7 +592,7 @@ private:
         m_moduleState(nodep).m_childCells.clear();
         m_modp = nullptr;
     }
-    virtual void visit(AstIfaceRefDType* nodep) override {
+    void visit(AstIfaceRefDType* nodep) override {
         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
@@ -602,15 +602,15 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstCell* nodep) override {  // LCOV_EXCL_START
+    void visit(AstCell* nodep) override {  // LCOV_EXCL_START
         nodep->v3fatal("Traversal should have been short circuited");
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         nodep->v3fatal("Traversal should have been short circuited");
     }  // LCOV_EXCL_STOP
-    virtual void visit(AstNodeFile*) override {}  // Accelerate
-    virtual void visit(AstNodeDType*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeFile*) override {}  // Accelerate
+    void visit(AstNodeDType*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -618,7 +618,7 @@ public:
         : m_moduleState{moduleState} {
         iterate(nodep);
     }
-    virtual ~InlineVisitor() override {
+    ~InlineVisitor() override {
         V3Stats::addStat("Optimizations, Inlined instances", m_statCells);
     }
 };
@@ -639,8 +639,8 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep->topModulep()); }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstNetlist* nodep) override { iterateChildren(nodep->topModulep()); }
+    void visit(AstCell* nodep) override {
         VL_RESTORER(m_scope);
         if (m_scope.empty()) {
             m_scope = nodep->name();
@@ -673,7 +673,7 @@ private:
             iterateChildren(modp);
         }
     }
-    virtual void visit(AstAssignVarScope* nodep) override {
+    void visit(AstAssignVarScope* nodep) override {
         // Reference
         const AstVarRef* const reflp = VN_CAST(nodep->lhsp(), VarRef);
         // What the reference refers to
@@ -698,14 +698,14 @@ private:
         cellp->addIntfRefp(new AstIntfRef(varlp->fileline(), alias));
     }
     //--------------------
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNodeStmt*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNodeStmt*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit InlineIntfRefVisitor(AstNode* nodep) { iterate(nodep); }
-    virtual ~InlineIntfRefVisitor() override = default;
+    ~InlineIntfRefVisitor() override = default;
 };
 
 //######################################################################

src/V3Inst.cpp

@@ -49,7 +49,7 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         UINFO(4, "  CELL   " << nodep << endl);
         m_cellp = nodep;
         // VV*****  We reset user1p() on each cell!!!
@@ -57,7 +57,7 @@ private:
         iterateChildren(nodep);
         m_cellp = nullptr;
     }
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         // 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);
@@ -116,7 +116,7 @@ private:
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
 
-    virtual void visit(AstUdpTable* nodep) override {
+    void visit(AstUdpTable* nodep) override {
         if (!v3Global.opt.bboxUnsup()) {
             // If we support primitives, update V3Undriven to remove special case
             nodep->v3warn(E_UNSUPPORTED, "Unsupported: Verilog 1995 UDP Tables. "
@@ -125,17 +125,17 @@ private:
     }
 
     // Save some time
-    virtual void visit(AstNodeMath*) override {}
-    virtual void visit(AstNodeAssign*) override {}
-    virtual void visit(AstAlways*) override {}
+    void visit(AstNodeMath*) override {}
+    void visit(AstNodeAssign*) override {}
+    void visit(AstAlways*) override {}
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit InstVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~InstVisitor() override = default;
+    ~InstVisitor() override = default;
 };
 
 //######################################################################
@@ -149,15 +149,15 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (VN_IS(nodep->dtypep(), IfaceRefDType)) {
             UINFO(8, "   dm-1-VAR    " << nodep << endl);
             insert(nodep);
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // METHODS
@@ -181,7 +181,7 @@ public:
 
     // CONSTRUCTORS
     InstDeModVarVisitor() = default;
-    virtual ~InstDeModVarVisitor() override = default;
+    ~InstDeModVarVisitor() override = default;
     void main(AstNodeModule* nodep) {
         UINFO(8, "  dmMODULE    " << nodep << endl);
         m_modVarNameMap.clear();
@@ -203,7 +203,7 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (VN_IS(nodep->dtypep(), UnpackArrayDType)
             && VN_IS(VN_AS(nodep->dtypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType)) {
             UINFO(8, "   dv-vec-VAR    " << nodep << endl);
@@ -239,7 +239,7 @@ private:
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         UINFO(4, "  CELL   " << nodep << endl);
         // Find submodule vars
         UASSERT_OBJ(nodep->modp(), nodep, "Unlinked");
@@ -316,7 +316,7 @@ private:
         }
     }
 
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         // Any non-direct pins need reconnection with a part-select
         if (!nodep->exprp()) return;  // No-connect
         if (m_cellRangep) {
@@ -478,13 +478,13 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit InstDeVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~InstDeVisitor() override = default;
+    ~InstDeVisitor() override = default;
 };
 
 //######################################################################

src/V3InstrCount.cpp

@@ -75,7 +75,7 @@ public:
         , m_osp{osp} {
         if (nodep) iterate(nodep);
     }
-    virtual ~InstrCountVisitor() override = default;
+    ~InstrCountVisitor() override = default;
 
     // METHODS
     uint32_t instrCount() const { return m_instrCount; }
@@ -117,7 +117,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeSel* nodep) override {
+    void visit(AstNodeSel* nodep) override {
         // This covers both AstArraySel and AstWordSel
         //
         // If some vector is a bazillion dwords long, and we're selecting 1
@@ -128,7 +128,7 @@ private:
         const VisitBase vb{this, nodep};
         iterateAndNextNull(nodep->bitp());
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         // Similar to AstNodeSel above, a small select into a large vector
         // is not expensive. Count the cost of the AstSel itself (scales with
         // its width) and the cost of the lsbp() and widthp() nodes, but not
@@ -137,13 +137,13 @@ private:
         iterateAndNextNull(nodep->lsbp());
         iterateAndNextNull(nodep->widthp());
     }
-    virtual void visit(AstSliceSel* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstSliceSel* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("AstSliceSel unhandled");
     }
-    virtual void visit(AstMemberSel* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstMemberSel* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("AstMemberSel unhandled");
     }
-    virtual void visit(AstConcat* nodep) override {
+    void visit(AstConcat* nodep) override {
         // Nop.
         //
         // Ignore concat. The problem with counting concat is that when we
@@ -163,7 +163,7 @@ private:
         // the widths of the operands (ignored here).
         markCost(nodep);
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         const VisitBase vb{this, nodep};
         iterateAndNextNull(nodep->condp());
         const uint32_t savedCount = m_instrCount;
@@ -188,7 +188,7 @@ private:
             if (nodep->ifsp()) nodep->ifsp()->user4(0);  // Don't dump it
         }
     }
-    virtual void visit(AstNodeCond* nodep) override {
+    void visit(AstNodeCond* nodep) override {
         // Just like if/else above, the ternary operator only evaluates
         // one of the two expressions, so only count the max.
         const VisitBase vb{this, nodep};
@@ -213,7 +213,7 @@ private:
             if (nodep->expr2p()) nodep->expr2p()->user4(0);  // Don't dump it
         }
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         // You'd think that the OrderLogicVertex's would be disjoint trees
         // of stuff in the AST, but it isn't so: V3Order makes an
         // OrderLogicVertex for each ACTIVE, and then also makes an
@@ -229,14 +229,14 @@ private:
         markCost(nodep);
         UASSERT_OBJ(nodep == m_startNodep, nodep, "Multiple actives, or not start node");
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         const VisitBase vb{this, nodep};
         iterateChildren(nodep);
         m_tracingCall = true;
         iterate(nodep->funcp());
         UASSERT_OBJ(!m_tracingCall, nodep, "visit(AstCFunc) should have cleared m_tracingCall.");
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         // Don't count a CFunc other than by tracing a call or counting it
         // from the root
         UASSERT_OBJ(m_tracingCall || nodep == m_startNodep, nodep,
@@ -249,7 +249,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         const VisitBase vb{this, nodep};
         iterateChildren(nodep);
     }
@@ -276,12 +276,12 @@ public:
         UASSERT_OBJ(osp, nodep, "Don't call if not dumping");
         if (nodep) iterate(nodep);
     }
-    virtual ~InstrCountDumpVisitor() override = default;
+    ~InstrCountDumpVisitor() override = default;
 
 private:
     // METHODS
     string indent() const { return string(m_depth, ':') + " "; }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         ++m_depth;
         if (unsigned costPlus1 = nodep->user4()) {
             *m_osp << "  " << indent() << "cost " << std::setw(6) << std::left << (costPlus1 - 1)

src/V3Life.cpp

@@ -291,7 +291,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // Consumption/generation of a variable,
         // it's used so can't elim assignment before this use.
         UASSERT_OBJ(nodep->varScopep(), nodep, "nullptr");
@@ -305,7 +305,7 @@ private:
             VL_DO_DANGLING(m_lifep->varUsageReplace(vscp, nodep), nodep);
         }
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         // Collect any used variables first, as lhs may also be on rhs
         // Similar code in V3Dead
         const uint64_t lastEdit = AstNode::editCountGbl();  // When it was last edited
@@ -325,13 +325,13 @@ private:
             iterateAndNextNull(nodep->lhsp());
         }
     }
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         // Don't treat as normal assign; V3Life doesn't understand time sense
         iterateChildren(nodep);
     }
 
     //---- Track control flow changes
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         UINFO(4, "   IF " << nodep << endl);
         // Condition is part of PREVIOUS block
         iterateAndNextNull(nodep->condp());
@@ -357,7 +357,7 @@ private:
         VL_DO_DANGLING(delete elseLifep, elseLifep);
     }
 
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         // 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
@@ -386,7 +386,7 @@ private:
         VL_DO_DANGLING(delete condLifep, condLifep);
         VL_DO_DANGLING(delete bodyLifep, bodyLifep);
     }
-    virtual void visit(AstJumpBlock* nodep) override {
+    void visit(AstJumpBlock* nodep) override {
         // 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.
@@ -404,7 +404,7 @@ private:
         bodyLifep->lifeToAbove();
         VL_DO_DANGLING(delete bodyLifep, bodyLifep);
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         // UINFO(4, "  CCALL " << nodep << endl);
         iterateChildren(nodep);
         // Enter the function and trace it
@@ -414,7 +414,7 @@ private:
             iterate(nodep->funcp());
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         // UINFO(4, "  CFUNC " << nodep << endl);
         if (!m_tracingCall && !nodep->entryPoint()) return;
         m_tracingCall = false;
@@ -423,17 +423,17 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstUCFunc* nodep) override {
+    void visit(AstUCFunc* nodep) override {
         m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
         iterateChildren(nodep);
     }
-    virtual void visit(AstCMath* nodep) override {
+    void visit(AstCMath* nodep) override {
         m_sideEffect = true;  // If appears on assign RHS, don't ever delete the assignment
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstVar*) override {}  // Don't want varrefs under it
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't want varrefs under it
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -446,7 +446,7 @@ public:
             if (m_lifep) VL_DO_CLEAR(delete m_lifep, m_lifep = nullptr);
         }
     }
-    virtual ~LifeVisitor() override {
+    ~LifeVisitor() override {
         if (m_lifep) VL_DO_CLEAR(delete m_lifep, m_lifep = nullptr);
     }
     VL_UNCOPYABLE(LifeVisitor);
@@ -462,20 +462,20 @@ private:
     LifeState* const m_statep;  // Current state
 
     // VISITORS
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (nodep->entryPoint()) {
             // Usage model 1: Simulate all C code, doing lifetime analysis
             LifeVisitor{nodep, m_statep};
         }
     }
-    virtual void visit(AstNodeProcedure* nodep) override {
+    void visit(AstNodeProcedure* nodep) override {
         // Usage model 2: Cleanup basic blocks
         LifeVisitor{nodep, m_statep};
     }
-    virtual void visit(AstVar*) override {}  // Accelerate
-    virtual void visit(AstNodeStmt*) override {}  // Accelerate
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Accelerate
+    void visit(AstNodeStmt*) override {}  // Accelerate
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -483,7 +483,7 @@ public:
         : m_statep{statep} {
         iterate(nodep);
     }
-    virtual ~LifeTopVisitor() override = default;
+    ~LifeTopVisitor() override = default;
 };
 
 //######################################################################

src/V3LifePost.cpp

@@ -54,7 +54,7 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         const AstVarScope* const vscp = nodep->varScopep();
         UASSERT_OBJ(vscp, nodep, "Scope not assigned");
         if (AstVarScope* const newvscp = reinterpret_cast<AstVarScope*>(vscp->user4p())) {
@@ -64,11 +64,11 @@ private:
             VL_DO_DANGLING(nodep->deleteTree(), nodep);
         }
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // Only track the top scopes, not lower level functions
         if (nodep->isTop()) iterateChildren(nodep);
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         iterateChildren(nodep);
         if (!nodep->funcp()->entryPoint()) {
             // Enter the function and trace it
@@ -76,23 +76,23 @@ private:
             iterate(nodep->funcp());
         }
     }
-    virtual void visit(AstExecGraph* nodep) override {
+    void visit(AstExecGraph* nodep) override {
         // Can just iterate across the MTask bodies in any order.  Order
         // isn't important for LifePostElimVisitor's simple substitution.
         iterateChildren(nodep);
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (!m_tracingCall && !nodep->entryPoint()) return;
         m_tracingCall = false;
         iterateChildren(nodep);
     }
-    virtual void visit(AstVar*) override {}  // Don't want varrefs under it
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't want varrefs under it
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit LifePostElimVisitor(AstTopScope* nodep) { iterate(nodep); }
-    virtual ~LifePostElimVisitor() override = default;
+    ~LifePostElimVisitor() override = default;
 };
 
 //######################################################################
@@ -250,7 +250,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep) override {
+    void visit(AstTopScope* nodep) override {
         AstNode::user4ClearTree();  // user4p() used on entire tree
 
         // First, build maps of every location (mtask and sequence
@@ -274,7 +274,7 @@ private:
         // Replace any node4p varscopes with the new scope
         LifePostElimVisitor{nodep};
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // Consumption/generation of a variable,
         const AstVarScope* const vscp = nodep->varScopep();
         UASSERT_OBJ(vscp, nodep, "Scope not assigned");
@@ -283,14 +283,14 @@ private:
         if (nodep->access().isWriteOrRW()) m_writes[vscp].insert(loc);
         if (nodep->access().isReadOrRW()) m_reads[vscp].insert(loc);
     }
-    virtual void visit(AstAssignPre* nodep) override {
+    void visit(AstAssignPre* nodep) override {
         // Do not record varrefs within assign pre.
         //
         // The pre-assignment into the dly var should not count as its
         // first write; we only want to consider reads and writes that
         // would still happen if the dly var were eliminated.
     }
-    virtual void visit(AstAssignPost* nodep) override {
+    void visit(AstAssignPost* nodep) override {
         // Don't record ASSIGNPOST in the read/write maps, record them in a
         // separate map
         if (const AstVarRef* const rhsp = VN_CAST(nodep->rhsp(), VarRef)) {
@@ -302,11 +302,11 @@ private:
             m_assignposts[dlyVarp] = LifePostLocation(loc, nodep);
         }
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // Only track the top scopes, not lower level functions
         if (nodep->isTop()) iterateChildren(nodep);
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         iterateChildren(nodep);
         if (!nodep->funcp()->entryPoint()) {
             // Enter the function and trace it
@@ -314,7 +314,7 @@ private:
             iterate(nodep->funcp());
         }
     }
-    virtual void visit(AstExecGraph* nodep) override {
+    void visit(AstExecGraph* nodep) override {
         // Treat the ExecGraph like a call to each mtask body
         UASSERT_OBJ(!m_mtasksGraphp, nodep, "Cannot handle more than one AstExecGraph");
         m_mtasksGraphp = nodep->depGraphp();
@@ -327,19 +327,19 @@ private:
         }
         m_execMTaskp = nullptr;
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (!m_tracingCall && !nodep->entryPoint()) return;
         m_tracingCall = false;
         iterateChildren(nodep);
     }
     //-----
-    virtual void visit(AstVar*) override {}  // Don't want varrefs under it
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't want varrefs under it
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit LifePostDlyVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~LifePostDlyVisitor() override {
+    ~LifePostDlyVisitor() override {
         V3Stats::addStat("Optimizations, Lifetime postassign deletions", m_statAssnDel);
     }
 };

src/V3LinkCells.cpp

@@ -45,8 +45,8 @@
 class LinkCellsGraph final : public V3Graph {
 public:
     LinkCellsGraph() = default;
-    virtual ~LinkCellsGraph() override = default;
-    virtual void loopsMessageCb(V3GraphVertex* vertexp) override;
+    ~LinkCellsGraph() override = default;
+    void loopsMessageCb(V3GraphVertex* vertexp) override;
 };
 
 class LinkCellsVertex final : public V3GraphVertex {
@@ -56,12 +56,12 @@ public:
     LinkCellsVertex(V3Graph* graphp, AstNodeModule* modp)
         : V3GraphVertex{graphp}
         , m_modp{modp} {}
-    virtual ~LinkCellsVertex() override = default;
+    ~LinkCellsVertex() override = default;
     AstNodeModule* modp() const { return m_modp; }
-    virtual string name() const override { return modp()->name(); }
-    virtual FileLine* fileline() const override { return modp()->fileline(); }
+    string name() const override { return modp()->name(); }
+    FileLine* fileline() const override { return modp()->fileline(); }
     // Recursive modules get space for maximum recursion
-    virtual uint32_t rankAdder() const override {
+    uint32_t rankAdder() const override {
         return m_modp->recursiveClone() ? (1 + v3Global.opt.moduleRecursionDepth()) : 1;
     }
 };
@@ -70,8 +70,8 @@ class LibraryVertex final : public V3GraphVertex {
 public:
     explicit LibraryVertex(V3Graph* graphp)
         : V3GraphVertex{graphp} {}
-    virtual ~LibraryVertex() override = default;
-    virtual string name() const override { return "*LIBRARY*"; }
+    ~LibraryVertex() override = default;
+    string name() const override { return "*LIBRARY*"; }
 };
 
 void LinkCellsGraph::loopsMessageCb(V3GraphVertex* vertexp) {
@@ -161,7 +161,7 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         AstNode::user1ClearTree();
         readModNames();
         iterateChildren(nodep);
@@ -181,8 +181,8 @@ private:
                                                << "' was not found in design.");
         }
     }
-    virtual void visit(AstConstPool* nodep) override {}
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstConstPool* nodep) override {}
+    void visit(AstNodeModule* nodep) override {
         // Module: Pick up modnames, so we can resolve cells later
         VL_RESTORER(m_modp);
         {
@@ -227,7 +227,7 @@ private:
         }
     }
 
-    virtual void visit(AstIfaceRefDType* nodep) override {
+    void visit(AstIfaceRefDType* nodep) override {
         // 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
@@ -246,14 +246,14 @@ private:
         // Note cannot do modport resolution here; modports are allowed underneath generates
     }
 
-    virtual void visit(AstPackageImport* nodep) override {
+    void visit(AstPackageImport* nodep) override {
         // Package Import: We need to do the package before the use of a package
         iterateChildren(nodep);
         UASSERT_OBJ(nodep->packagep(), nodep, "Unlinked package");  // Parser should set packagep
         new V3GraphEdge(&m_graph, vertex(m_modp), vertex(nodep->packagep()), 1, false);
     }
 
-    virtual void visit(AstBind* nodep) override {
+    void visit(AstBind* nodep) override {
         // 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
@@ -275,7 +275,7 @@ private:
         pushDeletep(nodep->unlinkFrBack());
     }
 
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         // Cell: Resolve its filename.  If necessary, parse it.
         // Execute only once.  Complication is that cloning may result in
         // user1 being set (for pre-clone) so check if user1() matches the
@@ -452,14 +452,14 @@ private:
         UINFO(4, " Link Cell done: " << nodep << endl);
     }
 
-    virtual void visit(AstRefDType* nodep) override {
+    void visit(AstRefDType* nodep) override {
         iterateChildren(nodep);
         for (AstPin* pinp = nodep->paramsp(); pinp; pinp = VN_AS(pinp->nextp(), Pin)) {
             pinp->param(true);
             if (pinp->name() == "") pinp->name("__paramNumber" + cvtToStr(pinp->pinNum()));
         }
     }
-    virtual void visit(AstClassOrPackageRef* nodep) override {
+    void visit(AstClassOrPackageRef* nodep) override {
         iterateChildren(nodep);
         // Inside a class, an extends or reference to another class
         // Note we don't add a V3GraphEdge{vertex(m_modp), vertex(nodep->classOrPackagep()}
@@ -471,7 +471,7 @@ private:
         }
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
     // METHODS
     void readModNames() {
@@ -528,7 +528,7 @@ public:
         }
         iterate(nodep);
     }
-    virtual ~LinkCellsVisitor() override = default;
+    ~LinkCellsVisitor() override = default;
 };
 
 //######################################################################

src/V3LinkDot.cpp

@@ -81,25 +81,25 @@
 
 class LinkNodeMatcherClass final : public VNodeMatcher {
 public:
-    virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Class); }
+    bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Class); }
 };
 class LinkNodeMatcherFTask final : public VNodeMatcher {
 public:
-    virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, NodeFTask); }
+    bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, NodeFTask); }
 };
 class LinkNodeMatcherModport final : public VNodeMatcher {
 public:
-    virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Modport); }
+    bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Modport); }
 };
 class LinkNodeMatcherVar final : public VNodeMatcher {
 public:
-    virtual bool nodeMatch(const AstNode* nodep) const override {
+    bool nodeMatch(const AstNode* nodep) const override {
         return VN_IS(nodep, Var) || VN_IS(nodep, LambdaArgRef);
     }
 };
 class LinkNodeMatcherVarIO final : public VNodeMatcher {
 public:
-    virtual bool nodeMatch(const AstNode* nodep) const override {
+    bool nodeMatch(const AstNode* nodep) const override {
         const AstVar* const varp = VN_CAST(nodep, Var);
         if (!varp) return false;
         return varp->isIO();
@@ -107,7 +107,7 @@ public:
 };
 class LinkNodeMatcherVarParam final : public VNodeMatcher {
 public:
-    virtual bool nodeMatch(const AstNode* nodep) const override {
+    bool nodeMatch(const AstNode* nodep) const override {
         const AstVar* const varp = VN_CAST(nodep, Var);
         if (!varp) return false;
         return varp->isParam();
@@ -742,7 +742,7 @@ class LinkDotFindVisitor final : public VNVisitor {
     }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Process $unit or other packages
         // Not needed - dotted references not allowed from inside packages
         // for (AstNodeModule* nodep = v3Global.rootp()->modulesp();
@@ -770,9 +770,9 @@ class LinkDotFindVisitor final : public VNVisitor {
             m_curSymp = m_modSymp = nullptr;
         }
     }
-    virtual void visit(AstTypeTable*) override {}
-    virtual void visit(AstConstPool*) override {}
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstTypeTable*) override {}
+    void visit(AstConstPool*) override {}
+    void visit(AstNodeModule* nodep) override {
         // Called on top module from Netlist, other modules from the cell creating them,
         // and packages
         UINFO(8, "   " << nodep << endl);
@@ -839,7 +839,7 @@ class LinkDotFindVisitor final : public VNVisitor {
             UINFO(5, "Module not under any CELL or top - dead module: " << nodep << endl);
         }
     }
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         UASSERT_OBJ(m_curSymp, nodep, "Class not under module/package/$unit");
         UINFO(8, "   " << nodep << endl);
         VL_RESTORER(m_scope);
@@ -871,12 +871,12 @@ class LinkDotFindVisitor final : public VNVisitor {
             if (!m_explicitNew && m_statep->forPrimary()) makeImplicitNew(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
                     "Scopes should only exist right after V3Scope");
         // Ignored.  Processed in next step
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         UINFO(5, "   CELL under " << m_scope << " is " << nodep << endl);
         // Process XREFs/etc inside pins
         if (nodep->recursive() && m_inRecursion) return;
@@ -911,7 +911,7 @@ class LinkDotFindVisitor final : public VNVisitor {
             if (nodep->modp()) iterate(nodep->modp());
         }
     }
-    virtual void visit(AstCellInline* nodep) override {
+    void visit(AstCellInline* nodep) override {
         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.
@@ -931,11 +931,11 @@ class LinkDotFindVisitor final : public VNVisitor {
             m_statep->insertInline(aboveSymp, m_modSymp, nodep, nodep->name());
         }
     }
-    virtual void visit(AstDefParam* nodep) override {
+    void visit(AstDefParam* nodep) override {
         nodep->user1p(m_curSymp);
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeBlock* nodep) override {
+    void visit(AstNodeBlock* nodep) override {
         UINFO(5, "   " << nodep << endl);
         if (nodep->name() == "" && nodep->unnamed()) {
             // Unnamed blocks are only important when they contain var
@@ -967,7 +967,7 @@ class LinkDotFindVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         // NodeTask: Remember its name for later resolution
         UINFO(5, "   " << nodep << endl);
         UASSERT_OBJ(m_curSymp && m_modSymp, nodep, "Function/Task not under module?");
@@ -1040,7 +1040,7 @@ class LinkDotFindVisitor final : public VNVisitor {
             m_ftaskp = nullptr;
         }
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         // Var: Remember its name for later resolution
         UASSERT_OBJ(m_curSymp && m_modSymp, nodep, "Var not under module?");
         iterateChildren(nodep);
@@ -1173,18 +1173,18 @@ class LinkDotFindVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstTypedef* nodep) override {
+    void visit(AstTypedef* nodep) override {
         UASSERT_OBJ(m_curSymp, nodep, "Typedef not under module/package/$unit");
         iterateChildren(nodep);
         m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
     }
-    virtual void visit(AstTypedefFwd* nodep) override {
+    void visit(AstTypedefFwd* nodep) override {
         UASSERT_OBJ(m_curSymp, nodep, "Typedef not under module/package/$unit");
         iterateChildren(nodep);
         // No need to insert, only the real typedef matters, but need to track for errors
         nodep->user1p(m_curSymp);
     }
-    virtual void visit(AstParamTypeDType* nodep) override {
+    void visit(AstParamTypeDType* nodep) override {
         UASSERT_OBJ(m_curSymp, nodep, "Parameter type not under module/package/$unit");
         iterateChildren(nodep);
         m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
@@ -1195,11 +1195,11 @@ class LinkDotFindVisitor final : public VNVisitor {
             symp->exported(false);
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         // For dotted resolution, ignore all AstVars under functions, otherwise shouldn't exist
         UASSERT_OBJ(!m_statep->forScopeCreation(), nodep, "No CFuncs expected in tree yet");
     }
-    virtual void visit(AstEnumItem* nodep) override {
+    void visit(AstEnumItem* nodep) override {
         // EnumItem: Remember its name for later resolution
         iterateChildren(nodep);
         // Find under either a task or the module's vars
@@ -1238,7 +1238,7 @@ class LinkDotFindVisitor final : public VNVisitor {
         }
         if (ins) m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
     }
-    virtual void visit(AstPackageImport* nodep) override {
+    void visit(AstPackageImport* nodep) override {
         UINFO(4, "  Link: " << nodep << endl);
         VSymEnt* const srcp = m_statep->getNodeSym(nodep->packagep());
         if (nodep->name() == "*") {
@@ -1256,7 +1256,7 @@ class LinkDotFindVisitor final : public VNVisitor {
         UINFO(9, "    Link Done: " << nodep << endl);
         // No longer needed, but can't delete until any multi-instantiated modules are expanded
     }
-    virtual void visit(AstPackageExport* nodep) override {
+    void visit(AstPackageExport* nodep) override {
         UINFO(9, "  Link: " << nodep << endl);
         VSymEnt* const srcp = m_statep->getNodeSym(nodep->packagep());
         if (nodep->name() != "*") {
@@ -1270,13 +1270,13 @@ class LinkDotFindVisitor final : public VNVisitor {
         UINFO(9, "    Link Done: " << nodep << endl);
         // No longer needed, but can't delete until any multi-instantiated modules are expanded
     }
-    virtual void visit(AstPackageExportStarStar* nodep) override {
+    void visit(AstPackageExportStarStar* nodep) override {
         UINFO(4, "  Link: " << nodep << endl);
         m_curSymp->exportStarStar(m_statep->symsp());
         // No longer needed, but can't delete until any multi-instantiated modules are expanded
     }
 
-    virtual void visit(AstForeach* nodep) override {
+    void visit(AstForeach* nodep) override {
         // Symbol table needs nodep->name() as the index variable's name
         VL_RESTORER(m_curSymp);
         VSymEnt* const oldCurSymp = m_curSymp;
@@ -1327,7 +1327,7 @@ class LinkDotFindVisitor final : public VNVisitor {
         }
     }
 
-    virtual void visit(AstWithParse* nodep) override {
+    void visit(AstWithParse* nodep) override {
         // Change WITHPARSE(FUNCREF, equation) to FUNCREF(WITH(equation))
         const auto funcrefp = VN_AS(nodep->funcrefp(), NodeFTaskRef);
         UASSERT_OBJ(funcrefp, nodep, "'with' only can operate on a function/task");
@@ -1355,7 +1355,7 @@ class LinkDotFindVisitor final : public VNVisitor {
         nodep->replaceWith(funcrefp->unlinkFrBack());
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
-    virtual void visit(AstWith* nodep) override {
+    void visit(AstWith* nodep) override {
         // Symbol table needs nodep->name() as the index variable's name
         // Iteration will pickup the AstVar we made under AstWith
         VL_RESTORER(m_curSymp);
@@ -1373,7 +1373,7 @@ class LinkDotFindVisitor final : public VNVisitor {
         }
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -1383,7 +1383,7 @@ public:
 
         iterate(rootp);
     }
-    virtual ~LinkDotFindVisitor() override = default;
+    ~LinkDotFindVisitor() override = default;
 };
 
 //======================================================================
@@ -1425,9 +1425,9 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstTypeTable*) override {}
-    virtual void visit(AstConstPool*) override {}
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstTypeTable*) override {}
+    void visit(AstConstPool*) override {}
+    void visit(AstNodeModule* nodep) override {
         UINFO(5, "   " << nodep << endl);
         if (nodep->dead() || !nodep->user4()) {
             UINFO(4, "Mark dead module " << nodep << endl);
@@ -1444,7 +1444,7 @@ private:
             m_modp = nullptr;
         }
     }
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         // Pin: Link to submodule's port
         // Deal with implicit definitions - do before Resolve visitor as may
         // be referenced above declaration
@@ -1453,7 +1453,7 @@ private:
             pinImplicitExprRecurse(nodep->exprp());
         }
     }
-    virtual void visit(AstDefParam* nodep) override {
+    void visit(AstDefParam* nodep) override {
         iterateChildren(nodep);
         nodep->v3warn(DEFPARAM, "defparam is deprecated (IEEE 1800-2017 C.4.1)\n"
                                     << nodep->warnMore()
@@ -1475,7 +1475,7 @@ private:
         }
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstPort* nodep) override {
+    void visit(AstPort* nodep) override {
         // Port: Stash the pin number
         // Need to set pin numbers after varnames are created
         // But before we do the final resolution based on names
@@ -1508,14 +1508,14 @@ private:
         // Ports not needed any more
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         // 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());
         iterateChildren(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep) override {
+    void visit(AstAssignAlias* nodep) override {
         // tran gates need implicit creation
         // As VarRefs don't exist in forPrimary, sanity check
         UASSERT_OBJ(!m_statep->forPrimary(), nodep, "Assign aliases unexpected pre-dot");
@@ -1527,13 +1527,13 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstImplicit* nodep) override {
+    void visit(AstImplicit* nodep) override {
         // Unsupported gates need implicit creation
         pinImplicitExprRecurse(nodep);
         // We're done with implicit gates
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstClassOrPackageRef* nodep) override {
+    void visit(AstClassOrPackageRef* nodep) override {
         if (auto* const fwdp = VN_CAST(nodep->classOrPackageNodep(), TypedefFwd)) {
             // Relink forward definitions to the "real" definition
             VSymEnt* const foundp = m_statep->getNodeSym(fwdp)->findIdFallback(fwdp->name());
@@ -1555,7 +1555,7 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstTypedefFwd* nodep) override {
+    void visit(AstTypedefFwd* nodep) override {
         VSymEnt* const foundp = m_statep->getNodeSym(nodep)->findIdFallback(nodep->name());
         if (!foundp && v3Global.opt.pedantic()) {
             // We only check it was ever really defined in pedantic mode, as it
@@ -1570,7 +1570,7 @@ private:
         VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -1579,7 +1579,7 @@ public:
         UINFO(4, __FUNCTION__ << ": " << endl);
         iterate(rootp);
     }
-    virtual ~LinkDotParamVisitor() override = default;
+    ~LinkDotParamVisitor() override = default;
 };
 
 //======================================================================
@@ -1594,12 +1594,12 @@ class LinkDotScopeVisitor final : public VNVisitor {
     static int debug() { return LinkDotState::debug(); }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Recurse..., backward as must do packages before using packages
         iterateChildrenBackwards(nodep);
     }
-    virtual void visit(AstConstPool*) override {}
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstConstPool*) override {}
+    void visit(AstScope* nodep) override {
         UINFO(8, "  SCOPE " << nodep << endl);
         UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
                     "Scopes should only exist right after V3Scope");
@@ -1611,7 +1611,7 @@ class LinkDotScopeVisitor final : public VNVisitor {
         m_modSymp = nullptr;
         m_scopep = nullptr;
     }
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         if (!nodep->varp()->isFuncLocal() && !nodep->varp()->isClassMember()) {
             VSymEnt* const varSymp
                 = m_statep->insertSym(m_modSymp, nodep->varp()->name(), nodep, nullptr);
@@ -1649,22 +1649,22 @@ class LinkDotScopeVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         VSymEnt* const symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, nullptr);
         symp->fallbackp(m_modSymp);
         // No recursion, we don't want to pick up variables
     }
-    virtual void visit(AstForeach* nodep) override {
+    void visit(AstForeach* nodep) override {
         VSymEnt* const symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, nullptr);
         symp->fallbackp(m_modSymp);
         // No recursion, we don't want to pick up variables
     }
-    virtual void visit(AstWith* nodep) override {
+    void visit(AstWith* nodep) override {
         VSymEnt* const symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, nullptr);
         symp->fallbackp(m_modSymp);
         // No recursion, we don't want to pick up variables
     }
-    virtual void visit(AstAssignAlias* nodep) override {
+    void visit(AstAssignAlias* nodep) override {
         // 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, "-    alias: ");
@@ -1674,7 +1674,7 @@ class LinkDotScopeVisitor final : public VNVisitor {
         fromVscp->user2p(toVscp);
         iterateChildren(nodep);
     }
-    virtual void visit(AstAssignVarScope* nodep) override {
+    void visit(AstAssignVarScope* nodep) override {
         UINFO(5, "ASSIGNVARSCOPE  " << nodep << endl);
         if (debug() >= 9) nodep->dumpTree(cout, "-    avs: ");
         VSymEnt* rhsSymp;
@@ -1734,9 +1734,9 @@ class LinkDotScopeVisitor final : public VNVisitor {
     }
     // 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*) override {}
-    virtual void visit(AstVar*) override {}
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstCell*) override {}
+    void visit(AstVar*) override {}
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -1745,7 +1745,7 @@ public:
         UINFO(4, __FUNCTION__ << ": " << endl);
         iterate(rootp);
     }
-    virtual ~LinkDotScopeVisitor() override = default;
+    ~LinkDotScopeVisitor() override = default;
 };
 
 //======================================================================
@@ -1760,7 +1760,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
     static int debug() { return LinkDotState::debug(); }
 
     // VISITs
-    virtual void visit(AstModport* nodep) override {
+    void visit(AstModport* nodep) override {
         // Modport: Remember its name for later resolution
         UINFO(5, "   fiv: " << nodep << endl);
         VL_RESTORER(m_curSymp);
@@ -1772,7 +1772,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstModportFTaskRef* nodep) override {
+    void visit(AstModportFTaskRef* nodep) override {
         UINFO(5, "   fif: " << nodep << endl);
         iterateChildren(nodep);
         if (nodep->isExport()) nodep->v3warn(E_UNSUPPORTED, "Unsupported: modport export");
@@ -1795,7 +1795,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
             VL_DO_DANGLING(pushDeletep(nodep), nodep);
         }
     }
-    virtual void visit(AstModportVarRef* nodep) override {
+    void visit(AstModportVarRef* nodep) override {
         UINFO(5, "   fiv: " << nodep << endl);
         iterateChildren(nodep);
         VSymEnt* const symp = m_curSymp->findIdFallback(nodep->name());
@@ -1820,7 +1820,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
             VL_DO_DANGLING(pushDeletep(nodep), nodep);
         }
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -1830,7 +1830,7 @@ public:
         UINFO(4, __FUNCTION__ << ": " << endl);
         iterate(nodep);
     }
-    virtual ~LinkDotIfaceVisitor() override = default;
+    ~LinkDotIfaceVisitor() override = default;
 };
 
 void LinkDotState::computeIfaceModSyms() {
@@ -2005,13 +2005,13 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Recurse..., backward as must do packages before using packages
         iterateChildrenBackwards(nodep);
     }
-    virtual void visit(AstTypeTable*) override {}
-    virtual void visit(AstConstPool*) override {}
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstTypeTable*) override {}
+    void visit(AstConstPool*) override {}
+    void visit(AstNodeModule* nodep) override {
         if (nodep->dead()) return;
         checkNoDot(nodep);
         UINFO(8, "  " << nodep << endl);
@@ -2025,7 +2025,7 @@ private:
         m_modp = nullptr;
         m_ds.m_dotSymp = m_curSymp = m_modSymp = nullptr;
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UINFO(8, "   " << nodep << endl);
         VL_RESTORER(m_modSymp);
         VL_RESTORER(m_curSymp);
@@ -2036,14 +2036,14 @@ private:
             m_ds.m_dotSymp = m_curSymp = m_modSymp = nullptr;
         }
     }
-    virtual void visit(AstCellInline* nodep) override {
+    void visit(AstCellInline* nodep) override {
         checkNoDot(nodep);
         if (m_statep->forScopeCreation() && !v3Global.opt.vpi()) {
             nodep->unlinkFrBack();
             VL_DO_DANGLING(pushDeletep(nodep), nodep);
         }
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         // Cell: Recurse inside or cleanup not founds
         checkNoDot(nodep);
         AstNode::user5ClearTree();
@@ -2072,7 +2072,7 @@ private:
         // Parent module inherits child's publicity
         // This is done bottom up in the LinkBotupVisitor stage
     }
-    virtual void visit(AstClassRefDType* nodep) override {
+    void visit(AstClassRefDType* nodep) override {
         // Cell: Recurse inside or cleanup not founds
         checkNoDot(nodep);
         AstNode::user5ClearTree();
@@ -2089,7 +2089,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         // Pin: Link to submodule's port
         checkNoDot(nodep);
         iterateChildren(nodep);
@@ -2130,7 +2130,7 @@ private:
         }
         // Early return() above when deleted
     }
-    virtual void visit(AstDot* nodep) override {
+    void visit(AstDot* nodep) override {
         // 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
@@ -2239,7 +2239,7 @@ private:
             m_ds.m_dotp = lastStates.m_dotp;
         }
     }
-    virtual void visit(AstParseRef* nodep) override {
+    void visit(AstParseRef* nodep) override {
         if (nodep->user3SetOnce()) return;
         UINFO(9, "   linkPARSEREF " << m_ds.ascii() << "  n=" << nodep << endl);
         // m_curSymp is symbol table of outer expression
@@ -2538,7 +2538,7 @@ private:
         }
         if (start) m_ds = lastStates;
     }
-    virtual void visit(AstClassOrPackageRef* nodep) override {
+    void visit(AstClassOrPackageRef* nodep) override {
         // Class: Recurse inside or cleanup not founds
         // checkNoDot not appropriate, can be under a dot
         AstNode::user5ClearTree();
@@ -2559,7 +2559,7 @@ private:
         }
     }
 
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // 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.
@@ -2581,7 +2581,7 @@ private:
             }
         }
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         // 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.
@@ -2661,18 +2661,18 @@ private:
             }
         }
     }
-    virtual void visit(AstEnumDType* nodep) override {
+    void visit(AstEnumDType* nodep) override {
         iterateChildren(nodep);
         AstRefDType* const refdtypep = VN_CAST(nodep->subDTypep(), RefDType);
         if (refdtypep && (nodep == refdtypep->subDTypep())) {
             refdtypep->v3error("Self-referential enumerated type definition");
         }
     }
-    virtual void visit(AstEnumItemRef* nodep) override {
+    void visit(AstEnumItemRef* nodep) override {
         // EnumItemRef may be under a dot.  Should already be resolved.
         iterateChildren(nodep);
     }
-    virtual void visit(AstMethodCall* nodep) override {
+    void visit(AstMethodCall* nodep) override {
         // Created here so should already be resolved.
         VL_RESTORER(m_ds);
         {
@@ -2680,7 +2680,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         checkNoDot(nodep);
         iterateChildren(nodep);
         if (m_statep->forPrimary() && nodep->isIO() && !m_ftaskp && !nodep->user4()) {
@@ -2688,7 +2688,7 @@ private:
                 "Input/output/inout does not appear in port list: " << nodep->prettyNameQ());
         }
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         if (nodep->user3SetOnce()) return;
         UINFO(8, "     " << nodep << endl);
         UINFO(8, "     " << m_ds.ascii() << endl);
@@ -2854,7 +2854,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstSelBit* nodep) override {
+    void visit(AstSelBit* nodep) override {
         if (nodep->user3SetOnce()) return;
         iterateAndNextNull(nodep->fromp());
         if (m_ds.m_dotPos
@@ -2882,7 +2882,7 @@ private:
             VL_DO_DANGLING(pushDeletep(nodep), nodep);
         }
     }
-    virtual void visit(AstNodePreSel* nodep) override {
+    void visit(AstNodePreSel* nodep) override {
         // Excludes simple AstSelBit, see above
         if (nodep->user3SetOnce()) return;
         if (m_ds.m_dotPos
@@ -2901,11 +2901,11 @@ private:
             iterateAndNextNull(nodep->attrp());
         }
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         // checkNoDot not appropriate, can be under a dot
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeBlock* nodep) override {
+    void visit(AstNodeBlock* nodep) override {
         UINFO(5, "   " << nodep << endl);
         checkNoDot(nodep);
         VSymEnt* const oldCurSymp = m_curSymp;
@@ -2919,7 +2919,7 @@ private:
         m_ds.m_dotSymp = m_curSymp = oldCurSymp;
         UINFO(5, "   cur=se" << cvtToHex(m_curSymp) << endl);
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         UINFO(5, "   " << nodep << endl);
         checkNoDot(nodep);
         if (nodep->isExternDef()) {
@@ -2941,7 +2941,7 @@ private:
         m_ds.m_dotSymp = m_curSymp = oldCurSymp;
         m_ftaskp = nullptr;
     }
-    virtual void visit(AstForeach* nodep) override {
+    void visit(AstForeach* nodep) override {
         UINFO(5, "   " << nodep << endl);
         checkNoDot(nodep);
         VSymEnt* const oldCurSymp = m_curSymp;
@@ -2951,7 +2951,7 @@ private:
         }
         m_ds.m_dotSymp = m_curSymp = oldCurSymp;
     }
-    virtual void visit(AstWith* nodep) override {
+    void visit(AstWith* nodep) override {
         UINFO(5, "   " << nodep << endl);
         checkNoDot(nodep);
         VSymEnt* const oldCurSymp = m_curSymp;
@@ -2961,12 +2961,12 @@ private:
         }
         m_ds.m_dotSymp = m_curSymp = oldCurSymp;
     }
-    virtual void visit(AstLambdaArgRef* nodep) override {
+    void visit(AstLambdaArgRef* nodep) override {
         UINFO(5, "   " << nodep << endl);
         // No checknodot(nodep), visit(AstScope) will check for LambdaArgRef
         iterateChildren(nodep);
     }
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         UINFO(5, "   " << nodep << endl);
         checkNoDot(nodep);
         VL_RESTORER(m_curSymp);
@@ -3041,7 +3041,7 @@ private:
             }
         }
     }
-    virtual void visit(AstRefDType* nodep) override {
+    void visit(AstRefDType* nodep) override {
         // Resolve its reference
         if (nodep->user3SetOnce()) return;
         if (AstNode* const cpackagep = nodep->classOrPackageOpp()) {
@@ -3112,7 +3112,7 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstDpiExport* nodep) override {
+    void visit(AstDpiExport* nodep) override {
         // AstDpiExport: Make sure the function referenced exists, then dump it
         iterateChildren(nodep);
         checkNoDot(nodep);
@@ -3130,35 +3130,35 @@ private:
         }
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstPackageImport* nodep) override {
+    void visit(AstPackageImport* nodep) override {
         // No longer needed
         checkNoDot(nodep);
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstPackageExport* nodep) override {
+    void visit(AstPackageExport* nodep) override {
         // No longer needed
         checkNoDot(nodep);
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstPackageExportStarStar* nodep) override {
+    void visit(AstPackageExportStarStar* nodep) override {
         // No longer needed
         checkNoDot(nodep);
         VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
     }
-    virtual void visit(AstCellRef* nodep) override {
+    void visit(AstCellRef* nodep) override {
         UINFO(5, "  AstCellRef: " << nodep << " " << m_ds.ascii() << endl);
         iterateChildren(nodep);
     }
-    virtual void visit(AstCellArrayRef* nodep) override {
+    void visit(AstCellArrayRef* nodep) override {
         UINFO(5, "  AstCellArrayRef: " << nodep << " " << m_ds.ascii() << endl);
         // Expression already iterated
     }
-    virtual void visit(AstUnlinkedRef* nodep) override {
+    void visit(AstUnlinkedRef* nodep) override {
         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) override {
+    void visit(AstNode* nodep) override {
         checkNoDot(nodep);
         iterateChildren(nodep);
     }
@@ -3170,7 +3170,7 @@ public:
         UINFO(4, __FUNCTION__ << ": " << endl);
         iterate(rootp);
     }
-    virtual ~LinkDotResolveVisitor() override = default;
+    ~LinkDotResolveVisitor() override = default;
 };
 
 //######################################################################

src/V3LinkInc.cpp

@@ -89,12 +89,12 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modIncrementsNum);
         m_modIncrementsNum = 0;
         iterateChildren(nodep);
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         // Special, as statements need to be put in different places
         // Preconditions insert first just before themselves (the normal
         // rule for other statement types)
@@ -111,7 +111,7 @@ private:
         // Done the loop
         m_insStmtp = nullptr;  // Next thing should be new statement
     }
-    virtual void visit(AstForeach* nodep) override {
+    void visit(AstForeach* nodep) override {
         // Special, as statements need to be put in different places
         // Body insert just before themselves
         m_insStmtp = nullptr;  // First thing should be new statement
@@ -119,7 +119,7 @@ private:
         // Done the loop
         m_insStmtp = nullptr;  // Next thing should be new statement
     }
-    virtual void visit(AstJumpBlock* nodep) override {
+    void visit(AstJumpBlock* nodep) override {
         // Special, as statements need to be put in different places
         // Body insert just before themselves
         m_insStmtp = nullptr;  // First thing should be new statement
@@ -127,7 +127,7 @@ private:
         // Done the loop
         m_insStmtp = nullptr;  // Next thing should be new statement
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         m_insStmtp = nodep;
         iterateAndNextNull(nodep->condp());
         m_insStmtp = nullptr;
@@ -135,7 +135,7 @@ private:
         iterateAndNextNull(nodep->elsesp());
         m_insStmtp = nullptr;
     }
-    virtual void visit(AstCaseItem* nodep) override {
+    void visit(AstCaseItem* nodep) override {
         m_insMode = IM_BEFORE;
         {
             VL_RESTORER(m_unsupportedHere);
@@ -145,11 +145,11 @@ private:
         m_insStmtp = nullptr;  // Next thing should be new statement
         iterateAndNextNull(nodep->bodysp());
     }
-    virtual void visit(AstNodeFor* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstNodeFor* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc(
             "For statements should have been converted to while statements in V3Begin.cpp");
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (!nodep->isStatement()) {
             iterateChildren(nodep);
             return;
@@ -165,11 +165,11 @@ private:
         UINFO(9, "Marking unsupported " << nodep << endl);
         iterateChildren(nodep);
     }
-    virtual void visit(AstLogAnd* nodep) override { unsupported_visit(nodep); }
-    virtual void visit(AstLogOr* nodep) override { unsupported_visit(nodep); }
-    virtual void visit(AstLogEq* nodep) override { unsupported_visit(nodep); }
-    virtual void visit(AstLogIf* nodep) override { unsupported_visit(nodep); }
-    virtual void visit(AstNodeCond* nodep) override { unsupported_visit(nodep); }
+    void visit(AstLogAnd* nodep) override { unsupported_visit(nodep); }
+    void visit(AstLogOr* nodep) override { unsupported_visit(nodep); }
+    void visit(AstLogEq* nodep) override { unsupported_visit(nodep); }
+    void visit(AstLogIf* nodep) override { unsupported_visit(nodep); }
+    void visit(AstNodeCond* nodep) override { unsupported_visit(nodep); }
     void prepost_visit(AstNodeTriop* nodep) {
         // Check if we are underneath a statement
         if (!m_insStmtp) {
@@ -257,17 +257,17 @@ private:
         nodep->replaceWith(new AstVarRef(varrefp->fileline(), varp, VAccess::WRITE));
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
-    virtual void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
-    virtual void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
-    virtual void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
-    virtual void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
-    virtual void visit(AstGenFor* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
+    void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
+    void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
+    void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
+    void visit(AstGenFor* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit LinkIncVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~LinkIncVisitor() override = default;
+    ~LinkIncVisitor() override = default;
 };
 
 //######################################################################

src/V3LinkJump.cpp

@@ -122,7 +122,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         if (nodep->dead()) return;
         VL_RESTORER(m_modp);
         VL_RESTORER(m_modRepeatNum);
@@ -132,12 +132,12 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         m_ftaskp = nodep;
         iterateChildren(nodep);
         m_ftaskp = nullptr;
     }
-    virtual void visit(AstNodeBlock* nodep) override {
+    void visit(AstNodeBlock* nodep) override {
         UINFO(8, "  " << nodep << endl);
         VL_RESTORER(m_inFork);
         m_blockStack.push_back(nodep);
@@ -147,7 +147,7 @@ private:
         }
         m_blockStack.pop_back();
     }
-    virtual void visit(AstRepeat* nodep) override {
+    void visit(AstRepeat* nodep) override {
         // 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.
@@ -175,7 +175,7 @@ private:
         nodep->replaceWith(newp);
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
-    virtual void visit(AstWait* nodep) override {
+    void visit(AstWait* nodep) override {
         nodep->v3warn(E_UNSUPPORTED, "Unsupported: wait statements");
         // Statements we'll just execute immediately; equivalent to if they followed this
         if (AstNode* const bodysp = nodep->bodysp()) {
@@ -186,7 +186,7 @@ private:
         }
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         // Don't need to track AstRepeat/AstFor as they have already been converted
         VL_RESTORER(m_loopp);
         VL_RESTORER(m_loopInc);
@@ -200,14 +200,14 @@ private:
             iterateAndNextNull(nodep->incsp());
         }
     }
-    virtual void visit(AstForeach* nodep) override {
+    void visit(AstForeach* nodep) override {
         VL_RESTORER(m_loopp);
         {
             m_loopp = nodep;
             iterateAndNextNull(nodep->bodysp());
         }
     }
-    virtual void visit(AstReturn* nodep) override {
+    void visit(AstReturn* nodep) override {
         iterateChildren(nodep);
         const AstFunc* const funcp = VN_CAST(m_ftaskp, Func);
         if (m_inFork) {
@@ -235,7 +235,7 @@ private:
         nodep->unlinkFrBack();
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstBreak* nodep) override {
+    void visit(AstBreak* nodep) override {
         iterateChildren(nodep);
         if (!m_loopp) {
             nodep->v3error("break isn't underneath a loop");
@@ -247,7 +247,7 @@ private:
         nodep->unlinkFrBack();
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstContinue* nodep) override {
+    void visit(AstContinue* nodep) override {
         iterateChildren(nodep);
         if (!m_loopp) {
             nodep->v3error("continue isn't underneath a loop");
@@ -260,7 +260,7 @@ private:
         nodep->unlinkFrBack();
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstDisable* nodep) override {
+    void visit(AstDisable* nodep) override {
         UINFO(8, "   DISABLE " << nodep << endl);
         iterateChildren(nodep);
         AstNodeBlock* blockp = nullptr;
@@ -285,16 +285,16 @@ private:
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
         // if (debug() >= 9) { UINFO(0, "\n"); beginp->dumpTree(cout, "  labelo: "); }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (m_loopInc && nodep->varp()) nodep->varp()->usedLoopIdx(true);
     }
-    virtual void visit(AstConst*) override {}
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstConst*) override {}
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit LinkJumpVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~LinkJumpVisitor() override = default;
+    ~LinkJumpVisitor() override = default;
 };
 
 //######################################################################

src/V3LinkLValue.cpp

@@ -46,7 +46,7 @@ private:
 
     // VISITs
     // Result handing
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         // VarRef: LValue its reference
         if (m_setRefLvalue != VAccess::NOCHANGE) nodep->access(m_setRefLvalue);
         if (nodep->varp()) {
@@ -65,7 +65,7 @@ private:
     }
 
     // Nodes that start propagating down lvalues
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         if (nodep->modVarp() && nodep->modVarp()->isWritable()) {
             // 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
@@ -76,7 +76,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         VL_RESTORER(m_setContinuously);
         {
@@ -92,7 +92,7 @@ private:
             iterateAndNextNull(nodep->rhsp());
         }
     }
-    virtual void visit(AstRelease* nodep) override {
+    void visit(AstRelease* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         VL_RESTORER(m_setContinuously);
         {
@@ -101,7 +101,7 @@ private:
             iterateAndNextNull(nodep->lhsp());
         }
     }
-    virtual void visit(AstCastDynamic* nodep) override {
+    void visit(AstCastDynamic* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::NOCHANGE;
@@ -110,7 +110,7 @@ private:
             iterateAndNextNull(nodep->top());
         }
     }
-    virtual void visit(AstFOpen* nodep) override {
+    void visit(AstFOpen* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -120,7 +120,7 @@ private:
             iterateAndNextNull(nodep->modep());
         }
     }
-    virtual void visit(AstFOpenMcd* nodep) override {
+    void visit(AstFOpenMcd* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -129,14 +129,14 @@ private:
             iterateAndNextNull(nodep->filenamep());
         }
     }
-    virtual void visit(AstFClose* nodep) override {
+    void visit(AstFClose* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
             iterateAndNextNull(nodep->filep());
         }
     }
-    virtual void visit(AstFError* nodep) override {
+    void visit(AstFError* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -144,21 +144,21 @@ private:
             iterateAndNextNull(nodep->strp());
         }
     }
-    virtual void visit(AstFFlush* nodep) override {
+    void visit(AstFFlush* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
             iterateAndNextNull(nodep->filep());
         }
     }
-    virtual void visit(AstFGetC* nodep) override {
+    void visit(AstFGetC* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
             iterateAndNextNull(nodep->filep());
         }
     }
-    virtual void visit(AstFGetS* nodep) override {
+    void visit(AstFGetS* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -166,7 +166,7 @@ private:
             iterateAndNextNull(nodep->strgp());
         }
     }
-    virtual void visit(AstFRead* nodep) override {
+    void visit(AstFRead* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -174,7 +174,7 @@ private:
             iterateAndNextNull(nodep->filep());
         }
     }
-    virtual void visit(AstFScanF* nodep) override {
+    void visit(AstFScanF* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -182,33 +182,33 @@ private:
             iterateAndNextNull(nodep->exprsp());
         }
     }
-    virtual void visit(AstFUngetC* nodep) override {
+    void visit(AstFUngetC* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
             iterateAndNextNull(nodep->filep());
         }
     }
-    virtual void visit(AstSScanF* nodep) override {
+    void visit(AstSScanF* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
             iterateAndNextNull(nodep->exprsp());
         }
     }
-    virtual void visit(AstSysIgnore* nodep) override {
+    void visit(AstSysIgnore* nodep) override {
         // Can't know if lvalue or not; presume so as stricter
         VL_RESTORER(m_setRefLvalue);
         iterateChildren(nodep);
     }
-    virtual void visit(AstRand* nodep) override {
+    void visit(AstRand* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             if (!nodep->urandom()) m_setRefLvalue = VAccess::WRITE;
             iterateAndNextNull(nodep->seedp());
         }
     }
-    virtual void visit(AstReadMem* nodep) override {
+    void visit(AstReadMem* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -219,14 +219,14 @@ private:
             iterateAndNextNull(nodep->msbp());
         }
     }
-    virtual void visit(AstTestPlusArgs* nodep) override {
+    void visit(AstTestPlusArgs* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::NOCHANGE;
             iterateAndNextNull(nodep->searchp());
         }
     }
-    virtual void visit(AstValuePlusArgs* nodep) override {
+    void visit(AstValuePlusArgs* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::NOCHANGE;
@@ -235,7 +235,7 @@ private:
             iterateAndNextNull(nodep->outp());
         }
     }
-    virtual void visit(AstSFormat* nodep) override {
+    void visit(AstSFormat* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             m_setRefLvalue = VAccess::WRITE;
@@ -254,13 +254,13 @@ private:
             iterateAndNextNull(nodep->thsp());
         }
     }
-    virtual void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
-    virtual void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
-    virtual void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
-    virtual void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
+    void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
+    void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
+    void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
+    void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
 
     // Nodes that change LValue state
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {
             iterateAndNextNull(nodep->lhsp());
@@ -270,7 +270,7 @@ private:
             iterateAndNextNull(nodep->thsp());
         }
     }
-    virtual void visit(AstNodeSel* nodep) override {
+    void visit(AstNodeSel* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {  // Only set lvalues on the from
             iterateAndNextNull(nodep->lhsp());
@@ -278,14 +278,14 @@ private:
             iterateAndNextNull(nodep->rhsp());
         }
     }
-    virtual void visit(AstCellArrayRef* nodep) override {
+    void visit(AstCellArrayRef* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {  // selp is not an lvalue
             m_setRefLvalue = VAccess::NOCHANGE;
             iterateAndNextNull(nodep->selp());
         }
     }
-    virtual void visit(AstNodePreSel* nodep) override {
+    void visit(AstNodePreSel* nodep) override {
         VL_RESTORER(m_setRefLvalue);
         {  // Only set lvalues on the from
             iterateAndNextNull(nodep->fromp());
@@ -294,12 +294,12 @@ private:
             iterateAndNextNull(nodep->thsp());
         }
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         m_ftaskp = nodep;
         iterateChildren(nodep);
         m_ftaskp = nullptr;
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         AstNode* pinp = nodep->pinsp();
         const AstNodeFTask* const taskp = nodep->taskp();
         // We'll deal with mismatching pins later
@@ -321,7 +321,7 @@ private:
         }
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -329,7 +329,7 @@ public:
         : m_setRefLvalue{start} {
         iterate(nodep);
     }
-    virtual ~LinkLValueVisitor() override = default;
+    ~LinkLValueVisitor() override = default;
 };
 
 //######################################################################

src/V3LinkParse.cpp

@@ -122,7 +122,7 @@ private:
     }
 
     // VISITs
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         if (!nodep->user1SetOnce()) {  // Process only once.
             V3Config::applyFTask(m_modp, nodep);
             cleanFileline(nodep);
@@ -139,7 +139,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         if (!nodep->user1SetOnce()) {  // Process only once.
             cleanFileline(nodep);
             UINFO(5, "   " << nodep << endl);
@@ -150,20 +150,20 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeDType* nodep) override { visitIterateNodeDType(nodep); }
-    virtual void visit(AstEnumDType* nodep) override {
+    void visit(AstNodeDType* nodep) override { visitIterateNodeDType(nodep); }
+    void visit(AstEnumDType* nodep) override {
         if (nodep->name() == "") {
             nodep->name(nameFromTypedef(nodep));  // Might still remain ""
         }
         visitIterateNodeDType(nodep);
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) override {
+    void visit(AstNodeUOrStructDType* nodep) override {
         if (nodep->name() == "") {
             nodep->name(nameFromTypedef(nodep));  // Might still remain ""
         }
         visitIterateNodeDType(nodep);
     }
-    virtual void visit(AstEnumItem* nodep) override {
+    void visit(AstEnumItem* nodep) override {
         // Expand ranges
         cleanFileline(nodep);
         iterateChildren(nodep);
@@ -198,7 +198,7 @@ private:
         }
     }
 
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         cleanFileline(nodep);
         if (nodep->lifetime().isNone()) {
             if (m_ftaskp) {
@@ -296,7 +296,7 @@ private:
         }
     }
 
-    virtual void visit(AstAttrOf* nodep) override {
+    void visit(AstAttrOf* nodep) override {
         cleanFileline(nodep);
         iterateChildren(nodep);
         if (nodep->attrType() == VAttrType::DT_PUBLIC) {
@@ -365,7 +365,7 @@ private:
         }
     }
 
-    virtual void visit(AstAlwaysPublic* nodep) override {
+    void visit(AstAlwaysPublic* nodep) override {
         // AlwaysPublic was attached under a var, but it's a statement that should be
         // at the same level as the var
         cleanFileline(nodep);
@@ -381,7 +381,7 @@ private:
         }
     }
 
-    virtual void visit(AstDefImplicitDType* nodep) override {
+    void visit(AstDefImplicitDType* nodep) override {
         cleanFileline(nodep);
         UINFO(8, "   DEFIMPLICIT " << nodep << endl);
         // Must remember what names we've already created, and combine duplicates
@@ -422,7 +422,7 @@ private:
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
 
-    virtual void visit(AstForeach* nodep) override {
+    void visit(AstForeach* nodep) override {
         // FOREACH(array, loopvars, body)
         UINFO(9, "FOREACH " << nodep << endl);
         // Separate iteration vars from base from variable
@@ -457,7 +457,7 @@ private:
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         V3Config::applyModule(nodep);
 
         VL_RESTORER(m_modp);
@@ -490,16 +490,16 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeProcedure* nodep) override { visitIterateNoValueMod(nodep); }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstNodeProcedure* nodep) override { visitIterateNoValueMod(nodep); }
+    void visit(AstAlways* nodep) override {
         VL_RESTORER(m_inAlways);
         m_inAlways = true;
         visitIterateNoValueMod(nodep);
     }
-    virtual void visit(AstCover* nodep) override { visitIterateNoValueMod(nodep); }
-    virtual void visit(AstRestrict* nodep) override { visitIterateNoValueMod(nodep); }
+    void visit(AstCover* nodep) override { visitIterateNoValueMod(nodep); }
+    void visit(AstRestrict* nodep) override { visitIterateNoValueMod(nodep); }
 
-    virtual void visit(AstBegin* nodep) override {
+    void visit(AstBegin* nodep) override {
         V3Config::applyCoverageBlock(m_modp, nodep);
         cleanFileline(nodep);
         const AstNode* const backp = nodep->backp();
@@ -525,7 +525,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstGenCase* nodep) override {
+    void visit(AstGenCase* nodep) override {
         ++m_genblkNum;
         cleanFileline(nodep);
         {
@@ -536,7 +536,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstGenIf* nodep) override {
+    void visit(AstGenIf* nodep) override {
         cleanFileline(nodep);
         const bool nestedIf
             = (VN_IS(nodep->backp(), Begin) && nestedIfBegin(VN_CAST(nodep->backp(), Begin)));
@@ -551,39 +551,39 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstCase* nodep) override {
+    void visit(AstCase* nodep) override {
         V3Config::applyCase(nodep);
         cleanFileline(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstPrintTimeScale* nodep) override {
+    void visit(AstPrintTimeScale* nodep) override {
         // Inlining may change hierarchy, so just save timescale where needed
         cleanFileline(nodep);
         iterateChildren(nodep);
         nodep->name(m_modp->name());
         nodep->timeunit(m_modp->timeunit());
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         cleanFileline(nodep);
         iterateChildren(nodep);
         nodep->timeunit(m_modp->timeunit());
     }
-    virtual void visit(AstTime* nodep) override {
+    void visit(AstTime* nodep) override {
         cleanFileline(nodep);
         iterateChildren(nodep);
         nodep->timeunit(m_modp->timeunit());
     }
-    virtual void visit(AstTimeD* nodep) override {
+    void visit(AstTimeD* nodep) override {
         cleanFileline(nodep);
         iterateChildren(nodep);
         nodep->timeunit(m_modp->timeunit());
     }
-    virtual void visit(AstTimeImport* nodep) override {
+    void visit(AstTimeImport* nodep) override {
         cleanFileline(nodep);
         iterateChildren(nodep);
         nodep->timeunit(m_modp->timeunit());
     }
-    virtual void visit(AstEventControl* nodep) override {
+    void visit(AstEventControl* nodep) override {
         cleanFileline(nodep);
         iterateChildren(nodep);
         AstAlways* const alwaysp = VN_CAST(nodep->backp(), Always);
@@ -605,7 +605,7 @@ private:
         }
     }
 
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         // Default: Just iterate
         cleanFileline(nodep);
         iterateChildren(nodep);
@@ -614,7 +614,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit LinkParseVisitor(AstNetlist* rootp) { iterate(rootp); }
-    virtual ~LinkParseVisitor() override = default;
+    ~LinkParseVisitor() override = default;
 };
 
 //######################################################################

src/V3LinkResolve.cpp

@@ -62,7 +62,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) override {
+    void visit(AstNodeModule* nodep) override {
         // Module: Create sim table for entire module and iterate
         UINFO(8, "MODULE " << nodep << endl);
         if (nodep->dead()) return;
@@ -74,14 +74,14 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         VL_RESTORER(m_classp);
         {
             m_classp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstInitialAutomatic* nodep) override {
+    void visit(AstInitialAutomatic* nodep) override {
         iterateChildren(nodep);
         // Initial assignments under function/tasks can just be simple
         // assignments without the initial
@@ -89,13 +89,13 @@ private:
             VL_DO_DANGLING(nodep->replaceWith(nodep->bodysp()->unlinkFrBackWithNext()), nodep);
         }
     }
-    virtual void visit(AstNodeCoverOrAssert* nodep) override {
+    void visit(AstNodeCoverOrAssert* nodep) override {
         if (m_assertp) nodep->v3error("Assert not allowed under another assert");
         m_assertp = nodep;
         iterateChildren(nodep);
         m_assertp = nullptr;
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         iterateChildren(nodep);
         if (m_classp && !nodep->isParam()) nodep->varType(VVarType::MEMBER);
         if (m_ftaskp) nodep->funcLocal(true);
@@ -105,13 +105,13 @@ private:
         }
     }
 
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         // VarRef: Resolve its reference
         if (nodep->varp()) nodep->varp()->usedParam(true);
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         // NodeTask: Remember its name for later resolution
         if (m_underGenerate) nodep->underGenerate(true);
         // Remember the existing symbol table scope
@@ -139,14 +139,14 @@ private:
         m_ftaskp = nullptr;
         if (nodep->dpiExport()) nodep->scopeNamep(new AstScopeName{nodep->fileline(), false});
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         iterateChildren(nodep);
         if (nodep->taskp() && (nodep->taskp()->dpiContext() || nodep->taskp()->dpiExport())) {
             nodep->scopeNamep(new AstScopeName{nodep->fileline(), false});
         }
     }
 
-    virtual void visit(AstSenItem* nodep) override {
+    void visit(AstSenItem* nodep) override {
         // Remove bit selects, and bark if it's not a simple variable
         iterateChildren(nodep);
         if (nodep->isClocked()) {
@@ -214,7 +214,7 @@ private:
         }
     }
 
-    virtual void visit(AstNodePreSel* nodep) override {
+    void visit(AstNodePreSel* nodep) override {
         if (!nodep->attrp()) {
             iterateChildren(nodep);
             // Constification may change the fromp() to a constant, which will lose the
@@ -249,7 +249,7 @@ private:
         }
     }
 
-    virtual void visit(AstCaseItem* nodep) override {
+    void visit(AstCaseItem* nodep) override {
         // 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
         iterateChildren(nodep);
@@ -261,7 +261,7 @@ private:
         }
     }
 
-    virtual void visit(AstPragma* nodep) override {
+    void visit(AstPragma* nodep) override {
         if (nodep->pragType() == VPragmaType::HIER_BLOCK) {
             UASSERT_OBJ(m_modp, nodep, "HIER_BLOCK not under a module");
             // If this is hierarchical mode which is to lib-create,
@@ -411,39 +411,39 @@ private:
         if (filep && filep->varp()) filep->varp()->attrFileDescr(true);
     }
 
-    virtual void visit(AstFOpen* nodep) override {
+    void visit(AstFOpen* nodep) override {
         iterateChildren(nodep);
         expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
     }
-    virtual void visit(AstFOpenMcd* nodep) override {
+    void visit(AstFOpenMcd* nodep) override {
         iterateChildren(nodep);
         expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
     }
-    virtual void visit(AstFClose* nodep) override {
+    void visit(AstFClose* nodep) override {
         iterateChildren(nodep);
         expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
     }
-    virtual void visit(AstFError* nodep) override {
+    void visit(AstFError* nodep) override {
         iterateChildren(nodep);
         expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
     }
-    virtual void visit(AstFEof* nodep) override {
+    void visit(AstFEof* nodep) override {
         iterateChildren(nodep);
         expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
     }
-    virtual void visit(AstFRead* nodep) override {
+    void visit(AstFRead* nodep) override {
         iterateChildren(nodep);
         expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
     }
-    virtual void visit(AstFScanF* nodep) override {
+    void visit(AstFScanF* nodep) override {
         iterateChildren(nodep);
         expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstSScanF* nodep) override {
+    void visit(AstSScanF* nodep) override {
         iterateChildren(nodep);
         expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         iterateChildren(nodep);
         // Cleanup old-school displays without format arguments
         if (!nodep->hasFormat()) {
@@ -466,7 +466,7 @@ private:
         }
     }
 
-    virtual void visit(AstUdpTable* nodep) override {
+    void visit(AstUdpTable* nodep) override {
         UINFO(5, "UDPTABLE  " << nodep << endl);
         if (!v3Global.opt.bboxUnsup()) {
             // We don't warn until V3Inst, so that UDPs that are in libraries and
@@ -497,49 +497,49 @@ private:
         }
     }
 
-    virtual void visit(AstScCtor* nodep) override {
+    void visit(AstScCtor* nodep) override {
         // Constructor info means the module must remain public
         m_modp->modPublic(true);
         iterateChildren(nodep);
     }
-    virtual void visit(AstScDtor* nodep) override {
+    void visit(AstScDtor* nodep) override {
         // Destructor info means the module must remain public
         m_modp->modPublic(true);
         iterateChildren(nodep);
     }
-    virtual void visit(AstScInt* nodep) override {
+    void visit(AstScInt* nodep) override {
         // Special class info means the module must remain public
         m_modp->modPublic(true);
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstIfaceRefDType* nodep) override {
+    void visit(AstIfaceRefDType* nodep) override {
         // LinkDot checked modports, now remove references to them
         // Keeping them later caused problems with InstDeArray,
         // as it needed to make new modport arrays and such
         nodep->modportp(nullptr);
         iterateChildren(nodep);
     }
-    // virtual void visit(AstModport* nodep) override { ... }
+    //  void visit(AstModport* nodep) override { ... }
     // We keep Modport's themselves around for XML dump purposes
 
-    virtual void visit(AstGenFor* nodep) override {
+    void visit(AstGenFor* nodep) override {
         VL_RESTORER(m_underGenerate);
         m_underGenerate = true;
         iterateChildren(nodep);
     }
-    virtual void visit(AstGenIf* nodep) override {
+    void visit(AstGenIf* nodep) override {
         VL_RESTORER(m_underGenerate);
         m_underGenerate = true;
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit LinkResolveVisitor(AstNetlist* rootp) { iterate(rootp); }
-    virtual ~LinkResolveVisitor() override = default;
+    ~LinkResolveVisitor() override = default;
 };
 
 //######################################################################
@@ -556,29 +556,29 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITs
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         // Iterate modules backwards, in bottom-up order.
         iterateChildrenBackwards(nodep);
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         // Parent module inherits child's publicity
         if (nodep->modp()->modPublic()) m_modp->modPublic(true);
         //** No iteration for speed
     }
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit LinkBotupVisitor(AstNetlist* rootp) { iterate(rootp); }
-    virtual ~LinkBotupVisitor() override = default;
+    ~LinkBotupVisitor() override = default;
 };
 
 //######################################################################

src/V3Localize.cpp

@@ -123,12 +123,12 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         iterateChildrenConst(nodep);
         moveVarScopes();
     }
 
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         UINFO(4, "  CFUNC " << nodep << endl);
         VL_RESTORER(m_cfuncp);
         VL_RESTORER(m_nodeDepth);
@@ -140,12 +140,12 @@ private:
         }
     }
 
-    virtual void visit(AstCCall* nodep) override {
+    void visit(AstCCall* nodep) override {
         m_cfuncp->user1(true);  // Mark caller as not a leaf function
         iterateChildrenConst(nodep);
     }
 
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         // Analyze RHS first so "a = a + 1" is detected as a read before write
         iterate(nodep->rhsp());
         // For now we only consider an assignment that is directly under the function, (in
@@ -163,7 +163,7 @@ private:
         iterate(nodep->lhsp());
     }
 
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         if (!nodep->varp()->isPrimaryIO()  // Not an IO the user wants to interact with
             && !nodep->varp()->isSigPublic()  // Not something the user wants to interact with
             && !nodep->varp()->isFuncLocal()  // Not already a function local (e.g.: argument)
@@ -177,7 +177,7 @@ private:
         // No iterate; Don't want varrefs under it (e.g.: in child dtype?)
     }
 
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         UASSERT_OBJ(m_cfuncp, nodep, "AstVarRef not under function");
 
         AstVarScope* const varScopep = nodep->varScopep();
@@ -201,7 +201,7 @@ private:
         // No iterate; Don't want varrefs under it  (e.g.: in child dtype?)
     }
 
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         ++m_nodeDepth;
         iterateChildrenConst(nodep);
         --m_nodeDepth;
@@ -210,7 +210,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit LocalizeVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~LocalizeVisitor() override {
+    ~LocalizeVisitor() override {
         V3Stats::addStat("Optimizations, Vars localized", m_statLocVars);
     }
 };

src/V3MergeCond.cpp

@@ -823,7 +823,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         if (AstNode* const condp = (*m_stmtPropertiesp)(nodep).m_condp) {
             // Check if mergeable
             if (!checkOrMakeMergeable(nodep)) return;
@@ -836,7 +836,7 @@ private:
         }
     }
 
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         // Check if mergeable
         if (!checkOrMakeMergeable(nodep)) {
             // If not mergeable, try to merge the branches
@@ -850,25 +850,25 @@ private:
         addToList(nodep, nodep->condp());
     }
 
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (m_mgFirstp && addIfHelpfulElseEndMerge(nodep)) return;
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         // Merge function body
         if (nodep->stmtsp()) process(nodep->stmtsp());
     }
 
     // For speed, only iterate what is necessary.
-    virtual void visit(AstNetlist* nodep) override { iterateAndNextNull(nodep->modulesp()); }
-    virtual void visit(AstNodeModule* nodep) override { iterateAndNextNull(nodep->stmtsp()); }
-    virtual void visit(AstNode* nodep) override {}
+    void visit(AstNetlist* nodep) override { iterateAndNextNull(nodep->modulesp()); }
+    void visit(AstNodeModule* nodep) override { iterateAndNextNull(nodep->stmtsp()); }
+    void visit(AstNode* nodep) override {}
 
 public:
     // CONSTRUCTORS
     explicit MergeCondVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~MergeCondVisitor() override {
+    ~MergeCondVisitor() override {
         V3Stats::addStat("Optimizations, MergeCond merges", m_statMerges);
         V3Stats::addStat("Optimizations, MergeCond merged items", m_statMergedItems);
         V3Stats::addStat("Optimizations, MergeCond longest merge", m_statLongestList);

src/V3Name.cpp

@@ -68,7 +68,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
@@ -76,44 +76,44 @@ private:
         }
     }
     // Add __PVT__ to names of local signals
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         // Don't iterate... Don't need temps for RANGES under the Var.
         rename(nodep,
                ((!m_modp || !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) override {
+    void visit(AstCFunc* nodep) override {
         if (!nodep->user1()) {
             iterateChildren(nodep);
             rename(nodep, false);
         }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (nodep->varp()) {
             iterate(nodep->varp());
             nodep->name(nodep->varp()->name());
         }
     }
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         if (!nodep->user1()) {
             rename(nodep, (!nodep->modp()->modPublic() && !VN_IS(nodep->modp(), ClassPackage)));
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstMemberDType* nodep) override {
+    void visit(AstMemberDType* nodep) override {
         if (!nodep->user1()) {
             rename(nodep, false);
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         if (!nodep->user1()) {
             rename(nodep, false);
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         if (!nodep->user1SetOnce()) {
             if (nodep->aboveScopep()) iterate(nodep->aboveScopep());
             if (nodep->aboveCellp()) iterate(nodep->aboveCellp());
@@ -130,12 +130,12 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit NameVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~NameVisitor() override = default;
+    ~NameVisitor() override = default;
 };
 
 //######################################################################

src/V3OptionParser.cpp

@@ -39,12 +39,12 @@ struct V3OptionParser::Impl {
     class ActionBase VL_NOT_FINAL : public ActionIfs {
         bool m_undocumented = false;  // This option is not documented
     public:
-        virtual bool isValueNeeded() const override final { return MODE == en::VALUE; }
-        virtual bool isFOnOffAllowed() const override final { return MODE == en::FONOFF; }
-        virtual bool isOnOffAllowed() const override final { return MODE == en::ONOFF; }
-        virtual bool isPartialMatchAllowed() const override final { return ALLOW_PARTIAL_MATCH; }
-        virtual bool isUndocumented() const override { return m_undocumented; }
-        virtual void undocumented() override { m_undocumented = true; }
+        bool isValueNeeded() const override final { return MODE == en::VALUE; }
+        bool isFOnOffAllowed() const override final { return MODE == en::FONOFF; }
+        bool isOnOffAllowed() const override final { return MODE == en::ONOFF; }
+        bool isPartialMatchAllowed() const override final { return ALLOW_PARTIAL_MATCH; }
+        bool isUndocumented() const override { return m_undocumented; }
+        void undocumented() override { m_undocumented = true; }
     };
 
     // Actual action classes
@@ -78,7 +78,7 @@ struct V3OptionParser::Impl {
     public: \
         explicit className(type* valp) \
             : m_valp(valp) {} \
-        virtual void exec(const char* optp, const char* argp) override { body; } \
+        void exec(const char* optp, const char* argp) override { body; } \
     }
 
 V3OPTION_PARSER_DEF_ACT_CLASS(ActionSet, bool, *m_valp = true, en::NONE);
@@ -104,7 +104,7 @@ V3OPTION_PARSER_DEF_ACT_CLASS(ActionOnOff, VOptionBool, m_valp->setTrueOrFalse(!
         using CbType = std::function<funcType>; \
         explicit className(CbType cb) \
             : m_cb(std::move(cb)) {} \
-        virtual void exec(const char* optp, const char* argp) override { body; } \
+        void exec(const char* optp, const char* argp) override { body; } \
     }
 
 V3OPTION_PARSER_DEF_ACT_CB_CLASS(ActionCbCall, void(void), m_cb(), en::NONE);

src/V3Order.cpp

@@ -157,7 +157,7 @@ static bool isClockerAssignment(AstNodeAssign* nodep) {
     private:
         // METHODS
         VL_DEBUG_FUNC;  // Declare debug()
-        virtual void visit(AstNodeAssign* nodep) override {
+        void visit(AstNodeAssign* nodep) override {
             if (const AstVarRef* const varrefp = VN_CAST(nodep->lhsp(), VarRef)) {
                 if (varrefp->varp()->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
                     m_clkAss = true;
@@ -166,8 +166,8 @@ static bool isClockerAssignment(AstNodeAssign* nodep) {
             }
             iterateChildren(nodep->rhsp());
         }
-        virtual void visit(AstNodeMath*) override {}  // Accelerate
-        virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+        void visit(AstNodeMath*) override {}  // Accelerate
+        void visit(AstNode* nodep) override { iterateChildren(nodep); }
     } visitor;
     visitor.iterate(nodep);
     return visitor.m_clkAss;
@@ -212,7 +212,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
     // METHODS
     VL_DEBUG_FUNC;  // Declare debug()
 
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         m_hasClk = false;
         m_inAss = true;
         m_childClkWidth = 0;
@@ -236,7 +236,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (m_inAss && nodep->varp()->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
             if (m_inClocked) {
                 nodep->v3warn(CLKDATA,
@@ -249,7 +249,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstConcat* nodep) override {
+    void visit(AstConcat* nodep) override {
         if (m_inAss) {
             iterateAndNextNull(nodep->lhsp());
             const int lw = m_childClkWidth;
@@ -258,20 +258,20 @@ class OrderClkMarkVisitor final : public VNVisitor {
             m_childClkWidth = lw + rw;  // Pass up
         }
     }
-    virtual void visit(AstNodeSel* nodep) override {
+    void visit(AstNodeSel* nodep) override {
         if (m_inAss) {
             iterateChildren(nodep);
             // Pass up result width
             if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
         }
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         if (m_inAss) {
             iterateChildren(nodep);
             if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
         }
     }
-    virtual void visit(AstReplicate* nodep) override {
+    void visit(AstReplicate* nodep) override {
         if (m_inAss) {
             iterateChildren(nodep);
             if (VN_IS(nodep->rhsp(), Const)) {
@@ -281,12 +281,12 @@ class OrderClkMarkVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         m_inClocked = nodep->hasClocked();
         iterateChildren(nodep);
         m_inClocked = false;
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
     // CONSTRUCTORS
     explicit OrderClkMarkVisitor(AstNode* nodep) {
@@ -295,7 +295,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
             iterate(nodep);
         } while (m_newClkMarked);
     }
-    virtual ~OrderClkMarkVisitor() override = default;
+    ~OrderClkMarkVisitor() override = default;
 
 public:
     static void process(AstNetlist* nodep) { OrderClkMarkVisitor{nodep}; }
@@ -416,19 +416,19 @@ class OrderBuildVisitor final : public VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstSenTree* nodep) override {
+    void visit(AstSenTree* nodep) override {
         // This should only find the global AstSenTrees under the AstTopScope, which we ignore
         // here. We visit AstSenTrees separately when encountering the AstActive that references
         // them.
         UASSERT_OBJ(!m_scopep, nodep, "AstSenTrees should have been made global in V3ActiveTop");
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UASSERT_OBJ(!m_scopep, nodep, "Should not nest");
         m_scopep = nodep;
         iterateChildren(nodep);
         m_scopep = nullptr;
     }
-    virtual void visit(AstActive* nodep) override {
+    void visit(AstActive* nodep) override {
         UASSERT_OBJ(!nodep->sensesStorep(), nodep,
                     "AstSenTrees should have been made global in V3ActiveTop");
         UASSERT_OBJ(m_scopep, nodep, "AstActive not under AstScope");
@@ -460,7 +460,7 @@ class OrderBuildVisitor final : public VNVisitor {
         m_activeSenVxp = nullptr;
         m_domainp = nullptr;
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         // As we explicitly not visit (see ignored nodes below) any subtree that is not relevant
         // for ordering, we should be able to assert this:
         UASSERT_OBJ(m_scopep, nodep, "AstVarRef not under scope");
@@ -635,7 +635,7 @@ class OrderBuildVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstDpiExportUpdated* nodep) override {
+    void visit(AstDpiExportUpdated* nodep) override {
         // This is under a logic block (AstAlways) sensitive to a change in the DPI export trigger.
         // We just need to add an edge to the enclosing logic vertex (the vertex for the
         // AstAlways).
@@ -645,7 +645,7 @@ class OrderBuildVisitor final : public VNVisitor {
         nodep->unlinkFrBack();
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstCCall* nodep) override {
+    void visit(AstCCall* nodep) override {
         // Calls to 'context' imported DPI function may call DPI exported functions
         if (m_dpiExportTriggerVxp && nodep->funcp()->dpiImportWrapper()
             && nodep->funcp()->dpiContext()) {
@@ -656,45 +656,45 @@ class OrderBuildVisitor final : public VNVisitor {
     }
 
     //--- Logic akin to SystemVerilog Processes (AstNodeProcedure)
-    virtual void visit(AstInitial* nodep) override {  //
+    void visit(AstInitial* nodep) override {  //
         iterateLogic(nodep);
     }
-    virtual void visit(AstInitialAutomatic* nodep) override {  //
+    void visit(AstInitialAutomatic* nodep) override {  //
         iterateLogic(nodep);
     }
-    virtual void visit(AstInitialStatic* nodep) override {  //
+    void visit(AstInitialStatic* nodep) override {  //
         iterateLogic(nodep);
     }
-    virtual void visit(AstAlways* nodep) override {  //
+    void visit(AstAlways* nodep) override {  //
         iterateLogic(nodep);
     }
-    virtual void visit(AstAlwaysPost* nodep) override {
+    void visit(AstAlwaysPost* nodep) override {
         UASSERT_OBJ(!m_inPost, nodep, "Should not nest");
         m_inPost = true;
         iterateLogic(nodep);
         m_inPost = false;
     }
-    virtual void visit(AstAlwaysPostponed* nodep) override {
+    void visit(AstAlwaysPostponed* nodep) override {
         UASSERT_OBJ(!m_inPostponed, nodep, "Should not nest");
         m_inPostponed = true;
         iterateLogic(nodep);
         m_inPostponed = false;
     }
-    virtual void visit(AstFinal* nodep) override {  // LCOV_EXCL_START
+    void visit(AstFinal* nodep) override {  // LCOV_EXCL_START
         nodep->v3fatalSrc("AstFinal should have been removed already");
     }  // LCOV_EXCL_STOP
 
     //--- Logic akin go SystemVerilog continuous assignments
-    virtual void visit(AstAssignAlias* nodep) override {  //
+    void visit(AstAssignAlias* nodep) override {  //
         iterateLogic(nodep);
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         UASSERT_OBJ(!m_inClkAss, nodep, "Should not nest");
         m_inClkAss = isClockerAssignment(nodep);
         iterateLogic(nodep);
         m_inClkAss = false;
     }
-    virtual void visit(AstAssignPre* nodep) override {
+    void visit(AstAssignPre* nodep) override {
         UASSERT_OBJ(!m_inClkAss && !m_inPre, nodep, "Should not nest");
         m_inClkAss = isClockerAssignment(nodep);
         m_inPre = true;
@@ -702,7 +702,7 @@ class OrderBuildVisitor final : public VNVisitor {
         m_inPre = false;
         m_inClkAss = false;
     }
-    virtual void visit(AstAssignPost* nodep) override {
+    void visit(AstAssignPost* nodep) override {
         UASSERT_OBJ(!m_inClkAss && !m_inPost, nodep, "Should not nest");
         m_inClkAss = isClockerAssignment(nodep);
         m_inPost = true;
@@ -712,21 +712,21 @@ class OrderBuildVisitor final : public VNVisitor {
     }
 
     //--- Verilator concoctions
-    virtual void visit(AstAlwaysPublic* nodep) override {  //
+    void visit(AstAlwaysPublic* nodep) override {  //
         iterateLogic(nodep);
     }
-    virtual void visit(AstCoverToggle* nodep) override {  //
+    void visit(AstCoverToggle* nodep) override {  //
         iterateLogic(nodep);
     }
 
     //--- Ignored nodes
-    virtual void visit(AstVar*) override {}
-    virtual void visit(AstVarScope* nodep) override {}
-    virtual void visit(AstCell*) override {}  // Only interested in the respective AstScope
-    virtual void visit(AstTypeTable*) override {}
-    virtual void visit(AstConstPool*) override {}
-    virtual void visit(AstClass*) override {}
-    virtual void visit(AstCFunc*) override {
+    void visit(AstVar*) override {}
+    void visit(AstVarScope* nodep) override {}
+    void visit(AstCell*) override {}  // Only interested in the respective AstScope
+    void visit(AstTypeTable*) override {}
+    void visit(AstConstPool*) override {}
+    void visit(AstClass*) override {}
+    void visit(AstCFunc*) override {
         // Calls to DPI exports handled with AstCCall. /* verilator public */ functions are
         // ignored for now (and hence potentially mis-ordered), but could use the same or
         // similar mechanism as DPI exports. Every other impure function (including those
@@ -734,7 +734,7 @@ class OrderBuildVisitor final : public VNVisitor {
     }
 
     //---
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
     // CONSTRUCTOR
     explicit OrderBuildVisitor(AstNetlist* nodep) {
@@ -981,15 +981,14 @@ public:
         : m_pomGraphp{pomGraphp}
         , m_pomWaitingp{pomWaitingp} {}
     // METHODS
-    virtual OrderMoveVertex* makeVertexp(OrderLogicVertex* lvertexp, const OrderEitherVertex*,
-                                         const AstScope* scopep,
-                                         const AstSenTree* domainp) override {
+    OrderMoveVertex* makeVertexp(OrderLogicVertex* lvertexp, const OrderEitherVertex*,
+                                 const AstScope* scopep, const AstSenTree* domainp) override {
         OrderMoveVertex* const resultp = new OrderMoveVertex(m_pomGraphp, lvertexp);
         resultp->domScopep(OrderMoveDomScope::findCreate(domainp, scopep));
         resultp->m_pomWaitingE.pushBack(*m_pomWaitingp, resultp);
         return resultp;
     }
-    virtual void freeVertexp(OrderMoveVertex* freeMep) override {
+    void freeVertexp(OrderMoveVertex* freeMep) override {
         freeMep->m_pomWaitingE.unlink(*m_pomWaitingp, freeMep);
         freeMep->unlinkDelete(m_pomGraphp);
     }
@@ -1005,18 +1004,14 @@ class OrderMTaskMoveVertexMaker final
 public:
     explicit OrderMTaskMoveVertexMaker(V3Graph* pomGraphp)
         : m_pomGraphp{pomGraphp} {}
-    virtual MTaskMoveVertex* makeVertexp(OrderLogicVertex* lvertexp,
-                                         const OrderEitherVertex* varVertexp,
-                                         const AstScope* scopep,
-                                         const AstSenTree* domainp) override {
+    MTaskMoveVertex* makeVertexp(OrderLogicVertex* lvertexp, const OrderEitherVertex* varVertexp,
+                                 const AstScope* scopep, const AstSenTree* domainp) override {
         // Exclude initial/settle logic from the mtasks graph.
         // We'll output time-zero logic separately.
         if (domainp->hasInitial() || domainp->hasSettle()) return nullptr;
         return new MTaskMoveVertex(m_pomGraphp, lvertexp, varVertexp, scopep, domainp);
     }
-    virtual void freeVertexp(MTaskMoveVertex* freeMep) override {
-        freeMep->unlinkDelete(m_pomGraphp);
-    }
+    void freeVertexp(MTaskMoveVertex* freeMep) override { freeMep->unlinkDelete(m_pomGraphp); }
 
 private:
     VL_UNCOPYABLE(OrderMTaskMoveVertexMaker);

src/V3OrderGraph.h

@@ -112,9 +112,9 @@ inline bool operator==(OrderVEdgeType::en lhs, const OrderVEdgeType& rhs) {
 class OrderGraph final : public V3Graph {
 public:
     OrderGraph() = default;
-    virtual ~OrderGraph() override = default;
+    ~OrderGraph() override = default;
     // Methods
-    virtual void loopsVertexCb(V3GraphVertex* vertexp) override;
+    void loopsVertexCb(V3GraphVertex* vertexp) override;
 };
 
 //######################################################################
@@ -136,12 +136,12 @@ public:
         : V3GraphVertex{graphp}
         , m_scopep{scopep}
         , m_domainp{domainp} {}
-    virtual ~OrderEitherVertex() override = default;
-    virtual OrderEitherVertex* clone(V3Graph* graphp) const override = 0;
+    ~OrderEitherVertex() override = default;
+    OrderEitherVertex* clone(V3Graph* graphp) const override = 0;
     // Methods
     virtual OrderVEdgeType type() const = 0;
     virtual bool domainMatters() = 0;  // Must be in same domain when cross edge to this vertex
-    virtual string dotName() const override { return cvtToHex(m_scopep) + "_"; }
+    string dotName() const override { return cvtToHex(m_scopep) + "_"; }
     // ACCESSORS
     void domainp(AstSenTree* domainp) { m_domainp = domainp; }
     AstScope* scopep() const { return m_scopep; }
@@ -159,16 +159,16 @@ public:
         : OrderEitherVertex{graphp, nullptr, domainp} {
         isFromInput(true);  // By definition
     }
-    virtual ~OrderInputsVertex() override = default;
-    virtual OrderInputsVertex* clone(V3Graph* graphp) const override {
+    ~OrderInputsVertex() override = default;
+    OrderInputsVertex* clone(V3Graph* graphp) const override {
         return new OrderInputsVertex(graphp, *this);
     }
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_INPUTS; }
-    virtual string name() const override { return "*INPUTS*"; }
-    virtual string dotColor() const override { return "green"; }
-    virtual string dotName() const override { return ""; }
-    virtual string dotShape() const override { return "invhouse"; }
-    virtual bool domainMatters() override { return false; }
+    OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_INPUTS; }
+    string name() const override { return "*INPUTS*"; }
+    string dotColor() const override { return "green"; }
+    string dotName() const override { return ""; }
+    string dotShape() const override { return "invhouse"; }
+    bool domainMatters() override { return false; }
 };
 
 class OrderLogicVertex final : public OrderEitherVertex {
@@ -183,20 +183,18 @@ public:
     OrderLogicVertex(V3Graph* graphp, AstScope* scopep, AstSenTree* domainp, AstNode* nodep)
         : OrderEitherVertex{graphp, scopep, domainp}
         , m_nodep{nodep} {}
-    virtual ~OrderLogicVertex() override = default;
-    virtual OrderLogicVertex* clone(V3Graph* graphp) const override {
+    ~OrderLogicVertex() override = default;
+    OrderLogicVertex* clone(V3Graph* graphp) const override {
         return new OrderLogicVertex(graphp, *this);
     }
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_LOGIC; }
-    virtual bool domainMatters() override { return true; }
+    OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_LOGIC; }
+    bool domainMatters() override { return true; }
     // ACCESSORS
-    virtual string name() const override {
+    string name() const override {
         return (cvtToHex(m_nodep) + "\\n " + cvtToStr(nodep()->typeName()));
     }
     AstNode* nodep() const { return m_nodep; }
-    virtual string dotShape() const override {
-        return VN_IS(m_nodep, Active) ? "doubleoctagon" : "rect";
-    }
+    string dotShape() const override { return VN_IS(m_nodep, Active) ? "doubleoctagon" : "rect"; }
 };
 
 class OrderVarVertex VL_NOT_FINAL : public OrderEitherVertex {
@@ -214,17 +212,17 @@ public:
     OrderVarVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
         : OrderEitherVertex{graphp, scopep, nullptr}
         , m_varScp{varScp} {}
-    virtual ~OrderVarVertex() override = default;
-    virtual OrderVarVertex* clone(V3Graph* graphp) const override = 0;
-    virtual OrderVEdgeType type() const override = 0;
-    virtual FileLine* fileline() const override { return varScp()->fileline(); }
+    ~OrderVarVertex() override = default;
+    OrderVarVertex* clone(V3Graph* graphp) const override = 0;
+    OrderVEdgeType type() const override = 0;
+    FileLine* fileline() const override { return varScp()->fileline(); }
     // ACCESSORS
     AstVarScope* varScp() const { return m_varScp; }
     void isClock(bool flag) { m_isClock = flag; }
     bool isClock() const { return m_isClock; }
     void isDelayed(bool flag) { m_isDelayed = flag; }
     bool isDelayed() const { return m_isDelayed; }
-    virtual string dotShape() const override { return "ellipse"; }
+    string dotShape() const override { return "ellipse"; }
 };
 
 class OrderVarStdVertex final : public OrderVarVertex {
@@ -234,16 +232,14 @@ class OrderVarStdVertex final : public OrderVarVertex {
 public:
     OrderVarStdVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
         : OrderVarVertex{graphp, scopep, varScp} {}
-    virtual ~OrderVarStdVertex() override = default;
-    virtual OrderVarStdVertex* clone(V3Graph* graphp) const override {
+    ~OrderVarStdVertex() override = default;
+    OrderVarStdVertex* clone(V3Graph* graphp) const override {
         return new OrderVarStdVertex(graphp, *this);
     }
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARSTD; }
-    virtual string name() const override {
-        return (cvtToHex(varScp()) + "\\n " + varScp()->name());
-    }
-    virtual string dotColor() const override { return "grey"; }
-    virtual bool domainMatters() override { return true; }
+    OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARSTD; }
+    string name() const override { return (cvtToHex(varScp()) + "\\n " + varScp()->name()); }
+    string dotColor() const override { return "grey"; }
+    bool domainMatters() override { return true; }
 };
 class OrderVarPreVertex final : public OrderVarVertex {
     OrderVarPreVertex(V3Graph* graphp, const OrderVarPreVertex& old)
@@ -252,16 +248,14 @@ class OrderVarPreVertex final : public OrderVarVertex {
 public:
     OrderVarPreVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
         : OrderVarVertex{graphp, scopep, varScp} {}
-    virtual ~OrderVarPreVertex() override = default;
-    virtual OrderVarPreVertex* clone(V3Graph* graphp) const override {
+    ~OrderVarPreVertex() override = default;
+    OrderVarPreVertex* clone(V3Graph* graphp) const override {
         return new OrderVarPreVertex(graphp, *this);
     }
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPRE; }
-    virtual string name() const override {
-        return (cvtToHex(varScp()) + " PRE\\n " + varScp()->name());
-    }
-    virtual string dotColor() const override { return "green"; }
-    virtual bool domainMatters() override { return false; }
+    OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPRE; }
+    string name() const override { return (cvtToHex(varScp()) + " PRE\\n " + varScp()->name()); }
+    string dotColor() const override { return "green"; }
+    bool domainMatters() override { return false; }
 };
 class OrderVarPostVertex final : public OrderVarVertex {
     OrderVarPostVertex(V3Graph* graphp, const OrderVarPostVertex& old)
@@ -270,16 +264,14 @@ class OrderVarPostVertex final : public OrderVarVertex {
 public:
     OrderVarPostVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
         : OrderVarVertex{graphp, scopep, varScp} {}
-    virtual OrderVarPostVertex* clone(V3Graph* graphp) const override {
+    OrderVarPostVertex* clone(V3Graph* graphp) const override {
         return new OrderVarPostVertex(graphp, *this);
     }
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPOST; }
-    virtual ~OrderVarPostVertex() override = default;
-    virtual string name() const override {
-        return (cvtToHex(varScp()) + " POST\\n " + varScp()->name());
-    }
-    virtual string dotColor() const override { return "red"; }
-    virtual bool domainMatters() override { return false; }
+    OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPOST; }
+    ~OrderVarPostVertex() override = default;
+    string name() const override { return (cvtToHex(varScp()) + " POST\\n " + varScp()->name()); }
+    string dotColor() const override { return "red"; }
+    bool domainMatters() override { return false; }
 };
 class OrderVarPordVertex final : public OrderVarVertex {
     OrderVarPordVertex(V3Graph* graphp, const OrderVarPordVertex& old)
@@ -288,16 +280,14 @@ class OrderVarPordVertex final : public OrderVarVertex {
 public:
     OrderVarPordVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
         : OrderVarVertex{graphp, scopep, varScp} {}
-    virtual ~OrderVarPordVertex() override = default;
-    virtual OrderVarPordVertex* clone(V3Graph* graphp) const override {
+    ~OrderVarPordVertex() override = default;
+    OrderVarPordVertex* clone(V3Graph* graphp) const override {
         return new OrderVarPordVertex(graphp, *this);
     }
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPORD; }
-    virtual string name() const override {
-        return (cvtToHex(varScp()) + " PORD\\n " + varScp()->name());
-    }
-    virtual string dotColor() const override { return "blue"; }
-    virtual bool domainMatters() override { return false; }
+    OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPORD; }
+    string name() const override { return (cvtToHex(varScp()) + " PORD\\n " + varScp()->name()); }
+    string dotColor() const override { return "blue"; }
+    bool domainMatters() override { return false; }
 };
 
 //######################################################################
@@ -324,28 +314,28 @@ public:
         , m_logicp{logicp}
         , m_state{POM_WAIT}
         , m_domScopep{nullptr} {}
-    virtual ~OrderMoveVertex() override = default;
-    virtual OrderMoveVertex* clone(V3Graph* graphp) const override {
+    ~OrderMoveVertex() override = default;
+    OrderMoveVertex* clone(V3Graph* graphp) const override {
         v3fatalSrc("Unsupported");
         return nullptr;
     }
     // METHODS
     virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_MOVE; }
-    virtual string dotColor() const override {
+    string dotColor() const override {
         if (logicp()) {
             return logicp()->dotColor();
         } else {
             return "";
         }
     }
-    virtual FileLine* fileline() const override {
+    FileLine* fileline() const override {
         if (logicp()) {
             return logicp()->fileline();
         } else {
             return nullptr;
         }
     }
-    virtual string name() const override {
+    string name() const override {
         string nm;
         if (VL_UNCOVERABLE(!logicp())) {  // Avoid crash when debugging
             nm = "nul";  // LCOV_EXCL_LINE
@@ -394,20 +384,20 @@ public:
         , m_domainp{domainp} {
         UASSERT(!(logicp && varp), "MTaskMoveVertex: logicp and varp may not both be set!\n");
     }
-    virtual ~MTaskMoveVertex() override = default;
-    virtual MTaskMoveVertex* clone(V3Graph* graphp) const override {
+    ~MTaskMoveVertex() override = default;
+    MTaskMoveVertex* clone(V3Graph* graphp) const override {
         v3fatalSrc("Unsupported");
         return nullptr;
     }
     virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_MOVE; }
-    virtual string dotColor() const override {
+    string dotColor() const override {
         if (logicp()) {
             return logicp()->dotColor();
         } else {
             return "yellow";
         }
     }
-    virtual string name() const override {
+    string name() const override {
         string nm;
         if (logicp()) {
             nm = logicp()->name();
@@ -439,10 +429,9 @@ public:
     OrderEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight,
               bool cutable = false)
         : V3GraphEdge{graphp, fromp, top, weight, cutable} {}
-    virtual ~OrderEdge() override = default;
+    ~OrderEdge() override = default;
     virtual OrderVEdgeType type() const { return OrderVEdgeType::EDGE_STD; }
-    virtual OrderEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
-                             V3GraphVertex* top) const override {
+    OrderEdge* clone(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) const override {
         return new OrderEdge(graphp, fromp, top, *this);
     }
     // When ordering combo blocks with stronglyConnected, follow edges not
@@ -466,14 +455,14 @@ class OrderComboCutEdge final : public OrderEdge {
 public:
     OrderComboCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : OrderEdge{graphp, fromp, top, WEIGHT_COMBO, CUTABLE} {}
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_COMBOCUT; }
-    virtual ~OrderComboCutEdge() override = default;
-    virtual OrderComboCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
-                                     V3GraphVertex* top) const override {
+    OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_COMBOCUT; }
+    ~OrderComboCutEdge() override = default;
+    OrderComboCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
+                             V3GraphVertex* top) const override {
         return new OrderComboCutEdge(graphp, fromp, top, *this);
     }
-    virtual string dotColor() const override { return "yellowGreen"; }
-    virtual bool followComboConnected() const override { return true; }
+    string dotColor() const override { return "yellowGreen"; }
+    bool followComboConnected() const override { return true; }
 };
 
 class OrderPostCutEdge final : public OrderEdge {
@@ -487,14 +476,14 @@ class OrderPostCutEdge final : public OrderEdge {
 public:
     OrderPostCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : OrderEdge{graphp, fromp, top, WEIGHT_COMBO, CUTABLE} {}
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_POSTCUT; }
-    virtual ~OrderPostCutEdge() override = default;
-    virtual OrderPostCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
-                                    V3GraphVertex* top) const override {
+    OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_POSTCUT; }
+    ~OrderPostCutEdge() override = default;
+    OrderPostCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
+                            V3GraphVertex* top) const override {
         return new OrderPostCutEdge(graphp, fromp, top, *this);
     }
-    virtual string dotColor() const override { return "PaleGreen"; }
-    virtual bool followComboConnected() const override { return false; }
+    string dotColor() const override { return "PaleGreen"; }
+    bool followComboConnected() const override { return false; }
 };
 
 class OrderPreCutEdge final : public OrderEdge {
@@ -508,14 +497,14 @@ class OrderPreCutEdge final : public OrderEdge {
 public:
     OrderPreCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : OrderEdge{graphp, fromp, top, WEIGHT_PRE, CUTABLE} {}
-    virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_PRECUT; }
-    virtual OrderPreCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
-                                   V3GraphVertex* top) const override {
+    OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_PRECUT; }
+    OrderPreCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
+                           V3GraphVertex* top) const override {
         return new OrderPreCutEdge(graphp, fromp, top, *this);
     }
-    virtual ~OrderPreCutEdge() override = default;
-    virtual string dotColor() const override { return "khaki"; }
-    virtual bool followComboConnected() const override { return false; }
+    ~OrderPreCutEdge() override = default;
+    string dotColor() const override { return "khaki"; }
+    bool followComboConnected() const override { return false; }
 };
 
 #endif  // Guard

src/V3Param.cpp

@@ -977,7 +977,7 @@ class ParamVisitor final : public VNVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         if (nodep->recursiveClone()) nodep->dead(true);  // Fake, made for recursive elimination
         if (nodep->dead()) return;  // Marked by LinkDot (and above)
 
@@ -995,14 +995,14 @@ class ParamVisitor final : public VNVisitor {
         }
     }
 
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         visitCellOrClassRef(nodep, VN_IS(nodep->modp(), Iface));
     }
-    virtual void visit(AstClassRefDType* nodep) override { visitCellOrClassRef(nodep, false); }
-    virtual void visit(AstClassOrPackageRef* nodep) override { visitCellOrClassRef(nodep, false); }
+    void visit(AstClassRefDType* nodep) override { visitCellOrClassRef(nodep, false); }
+    void visit(AstClassOrPackageRef* nodep) override { visitCellOrClassRef(nodep, false); }
 
     // Make sure all parameters are constantified
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (nodep->user5SetOnce()) return;  // Process once
         iterateChildren(nodep);
         if (nodep->isParam()) {
@@ -1015,7 +1015,7 @@ class ParamVisitor final : public VNVisitor {
         }
     }
     // Make sure varrefs cause vars to constify before things above
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // Might jump across functions, so beware if ever add a m_funcp
         if (nodep->varp()) iterate(nodep->varp());
     }
@@ -1036,7 +1036,7 @@ class ParamVisitor final : public VNVisitor {
         }
         return false;
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         // Check to see if the scope is just an interface because interfaces are special
         const string dotted = nodep->dotted();
         if (!dotted.empty() && nodep->varp() && nodep->varp()->isParam()) {
@@ -1082,7 +1082,7 @@ class ParamVisitor final : public VNVisitor {
         nodep->varp(nullptr);  // Needs relink, as may remove pointed-to var
     }
 
-    virtual void visit(AstUnlinkedRef* nodep) override {
+    void visit(AstUnlinkedRef* nodep) override {
         AstVarXRef* const varxrefp = VN_CAST(nodep->op1p(), VarXRef);
         AstNodeFTaskRef* const taskrefp = VN_CAST(nodep->op1p(), NodeFTaskRef);
         if (varxrefp) {
@@ -1103,7 +1103,7 @@ class ParamVisitor final : public VNVisitor {
         nodep->replaceWith(nodep->op1p()->unlinkFrBack());
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
     }
-    virtual void visit(AstCellArrayRef* nodep) override {
+    void visit(AstCellArrayRef* nodep) override {
         V3Const::constifyParamsEdit(nodep->selp());
         if (const AstConst* const constp = VN_CAST(nodep->selp(), Const)) {
             const string index = AstNode::encodeNumber(constp->toSInt());
@@ -1122,7 +1122,7 @@ class ParamVisitor final : public VNVisitor {
     }
 
     // Generate Statements
-    virtual void visit(AstGenIf* nodep) override {
+    void visit(AstGenIf* nodep) override {
         UINFO(9, "  GENIF " << nodep << endl);
         iterateAndNextNull(nodep->condp());
         // We suppress errors when widthing params since short-circuiting in
@@ -1149,7 +1149,7 @@ class ParamVisitor final : public VNVisitor {
     //! @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) override {
+    void visit(AstBegin* nodep) override {
         if (nodep->genforp()) {
             AstGenFor* const forp = VN_AS(nodep->genforp(), GenFor);
             UASSERT_OBJ(forp, nodep, "Non-GENFOR under generate-for BEGIN");
@@ -1181,10 +1181,10 @@ class ParamVisitor final : public VNVisitor {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstGenFor* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstGenFor* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("GENFOR should have been wrapped in BEGIN");
     }
-    virtual void visit(AstGenCase* nodep) override {
+    void visit(AstGenCase* nodep) override {
         UINFO(9, "  GENCASE " << nodep << endl);
         AstNode* keepp = nullptr;
         iterateAndNextNull(nodep->exprp());
@@ -1235,7 +1235,7 @@ class ParamVisitor final : public VNVisitor {
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -1272,7 +1272,7 @@ public:
             for (AstNodeModule* const modp : modps) netlistp->addModulep(modp);
         }
     }
-    virtual ~ParamVisitor() override = default;
+    ~ParamVisitor() override = default;
     VL_UNCOPYABLE(ParamVisitor);
 };
 

src/V3Partition.cpp

@@ -253,7 +253,7 @@ public:
         m_vertices.splice(m_vertices.end(), otherp->m_vertices);
         m_cost += otherp->m_cost;
     }
-    virtual const VxList* vertexListp() const override { return &m_vertices; }
+    const VxList* vertexListp() const override { return &m_vertices; }
     static uint64_t incGeneration() {
         static uint64_t s_generation = 0;
         ++s_generation;
@@ -263,10 +263,10 @@ public:
     // Use this instead of pointer-compares to compare LogicMTasks. Avoids
     // nondeterministic output.  Also name mtasks based on this number in
     // the final C++ output.
-    virtual uint32_t id() const override { return m_serialId; }
+    uint32_t id() const override { return m_serialId; }
     void id(uint32_t id) { m_serialId = id; }
     // Abstract cost of every logic mtask
-    virtual uint32_t cost() const override { return m_cost; }
+    uint32_t cost() const override { return m_cost; }
     void setCost(uint32_t cost) { m_cost = cost; }  // For tests only
     uint32_t stepCost() const { return stepCost(m_cost); }
     static uint32_t stepCost(uint32_t cost) {
@@ -319,7 +319,7 @@ public:
 
     void checkRelativesCp(GraphWay way) const;
 
-    virtual string name() const override {
+    string name() const override {
         // Display forward and reverse critical path costs. This gives a quick
         // read on whether graph partitioning looks reasonable or bad.
         std::ostringstream out;
@@ -1850,7 +1850,7 @@ private:
     // METHODS
     VL_DEBUG_FUNC;
 
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (!m_tracingCall) return;
         m_tracingCall = false;
         if (nodep->dpiImportWrapper()) {
@@ -1861,19 +1861,19 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         iterateChildren(nodep);
         // Enter the function and trace it
         m_tracingCall = true;
         iterate(nodep->funcp());
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit DpiImportCallVisitor(AstNode* nodep) { iterate(nodep); }
     bool hasDpiHazard() const { return m_hasDpiHazard; }
-    virtual ~DpiImportCallVisitor() override = default;
+    ~DpiImportCallVisitor() override = default;
 
 private:
     VL_UNCOPYABLE(DpiImportCallVisitor);

src/V3PartitionGraph.h

@@ -32,7 +32,7 @@ class AbstractMTask VL_NOT_FINAL : public V3GraphVertex {
 public:
     explicit AbstractMTask(V3Graph* graphp)
         : V3GraphVertex{graphp} {}
-    virtual ~AbstractMTask() override = default;
+    ~AbstractMTask() override = default;
     virtual uint32_t id() const = 0;
     virtual uint32_t cost() const = 0;
 };
@@ -44,12 +44,12 @@ public:
     // CONSTRUCTORS
     explicit AbstractLogicMTask(V3Graph* graphp)
         : AbstractMTask{graphp} {}
-    virtual ~AbstractLogicMTask() override = default;
+    ~AbstractLogicMTask() override = default;
     // METHODS
     // Set of logic vertices in this mtask. Order is not significant.
     virtual const VxList* vertexListp() const = 0;
-    virtual uint32_t id() const override = 0;  // Unique id of this mtask.
-    virtual uint32_t cost() const override = 0;
+    uint32_t id() const override = 0;  // Unique id of this mtask.
+    uint32_t cost() const override = 0;
 };
 
 class ExecMTask final : public AbstractMTask {
@@ -72,10 +72,10 @@ public:
         , m_bodyp{bodyp}
         , m_id{id} {}
     AstMTaskBody* bodyp() const { return m_bodyp; }
-    virtual uint32_t id() const override { return m_id; }
+    uint32_t id() const override { return m_id; }
     uint32_t priority() const { return m_priority; }
     void priority(uint32_t pri) { m_priority = pri; }
-    virtual uint32_t cost() const override { return m_cost; }
+    uint32_t cost() const override { return m_cost; }
     void cost(uint32_t cost) { m_cost = cost; }
     void predictStart(uint64_t time) { m_predictStart = time; }
     uint64_t predictStart() const { return m_predictStart; }
@@ -85,7 +85,7 @@ public:
         // If this MTask maps to a C function, this should be the name
         return std::string{"__Vmtask"} + "__" + cvtToStr(m_id);
     }
-    virtual string name() const override { return std::string{"mt"} + cvtToStr(id()); }
+    string name() const override { return std::string{"mt"} + cvtToStr(id()); }
     string hashName() const { return m_hashName; }
     void hashName(const string& name) { m_hashName = name; }
     void dump(std::ostream& str) const {

src/V3PreProc.cpp

@@ -250,13 +250,13 @@ public:
     void candidateDefines(VSpellCheck* spellerp) override;
 
     // METHODS, callbacks
-    virtual void comment(const string& text) override;  // Comment detected (if keepComments==2)
-    virtual void include(const string& filename) override;  // Request a include file be processed
-    virtual void undef(const string& name) override;
+    void comment(const string& text) override;  // Comment detected (if keepComments==2)
+    void include(const string& filename) override;  // Request a include file be processed
+    void undef(const string& name) override;
     virtual void undefineall();
-    virtual void define(FileLine* fl, const string& name, const string& value,
-                        const string& params, bool cmdline) override;
-    virtual string removeDefines(const string& text) override;  // Remove defines in a text string
+    void define(FileLine* fl, const string& name, const string& value, const string& params,
+                bool cmdline) override;
+    string removeDefines(const string& text) override;  // Remove defines in a text string
 
     // CONSTRUCTORS
     V3PreProcImp() {

src/V3Premit.cpp

@@ -151,11 +151,11 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         UINFO(4, " MOD   " << nodep << endl);
         iterateChildren(nodep);
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         VL_RESTORER(m_cfuncp);
         {
             m_cfuncp = nodep;
@@ -167,7 +167,7 @@ private:
         m_assignLhs = false;
         if (m_cfuncp) m_stmtp = nodep;
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         UINFO(4, "  WHILE  " << nodep << endl);
         startStatement(nodep);
         iterateAndNextNull(nodep->precondsp());
@@ -180,7 +180,7 @@ private:
         iterateAndNextNull(nodep->incsp());
         m_stmtp = nullptr;
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         startStatement(nodep);
         {
             bool noopt = false;
@@ -207,7 +207,7 @@ private:
         m_assignLhs = false;
         m_stmtp = nullptr;
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (!nodep->isStatement()) {
             iterateChildren(nodep);
             return;
@@ -217,7 +217,7 @@ private:
         iterateChildren(nodep);
         m_stmtp = nullptr;
     }
-    virtual void visit(AstTraceInc* nodep) override {
+    void visit(AstTraceInc* nodep) override {
         startStatement(nodep);
         m_inTracep = nodep;
         iterateChildren(nodep);
@@ -271,31 +271,31 @@ private:
         iterateChildren(nodep);
         checkNode(nodep);
     }
-    virtual void visit(AstShiftL* nodep) override { visitShift(nodep); }
-    virtual void visit(AstShiftR* nodep) override { visitShift(nodep); }
-    virtual void visit(AstShiftRS* nodep) override { visitShift(nodep); }
+    void visit(AstShiftL* nodep) override { visitShift(nodep); }
+    void visit(AstShiftR* nodep) override { visitShift(nodep); }
+    void visit(AstShiftRS* nodep) override { visitShift(nodep); }
     // Operators
-    virtual void visit(AstNodeTermop* nodep) override {
+    void visit(AstNodeTermop* nodep) override {
         iterateChildren(nodep);
         checkNode(nodep);
     }
-    virtual void visit(AstNodeUniop* nodep) override {
+    void visit(AstNodeUniop* nodep) override {
         iterateChildren(nodep);
         checkNode(nodep);
     }
-    virtual void visit(AstNodeBiop* nodep) override {
+    void visit(AstNodeBiop* nodep) override {
         iterateChildren(nodep);
         checkNode(nodep);
     }
-    virtual void visit(AstRand* nodep) override {
+    void visit(AstRand* nodep) override {
         iterateChildren(nodep);
         checkNode(nodep);
     }
-    virtual void visit(AstUCFunc* nodep) override {
+    void visit(AstUCFunc* nodep) override {
         iterateChildren(nodep);
         checkNode(nodep);
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         iterateAndNextNull(nodep->fromp());
         {  // Only the 'from' is part of the assignment LHS
             VL_RESTORER(m_assignLhs);
@@ -305,7 +305,7 @@ private:
         }
         checkNode(nodep);
     }
-    virtual void visit(AstArraySel* nodep) override {
+    void visit(AstArraySel* nodep) override {
         iterateAndNextNull(nodep->fromp());
         {  // Only the 'from' is part of the assignment LHS
             VL_RESTORER(m_assignLhs);
@@ -314,7 +314,7 @@ private:
         }
         checkNode(nodep);
     }
-    virtual void visit(AstAssocSel* nodep) override {
+    void visit(AstAssocSel* nodep) override {
         iterateAndNextNull(nodep->fromp());
         {  // Only the 'from' is part of the assignment LHS
             VL_RESTORER(m_assignLhs);
@@ -323,11 +323,11 @@ private:
         }
         checkNode(nodep);
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         iterateChildren(nodep);
         checkNode(nodep);
     }
-    virtual void visit(AstNodeCond* nodep) override {
+    void visit(AstNodeCond* nodep) override {
         iterateChildren(nodep);
         if (nodep->expr1p()->isWide() && !VN_IS(nodep->condp(), Const)
             && !VN_IS(nodep->condp(), VarRef)) {
@@ -339,7 +339,7 @@ private:
     }
 
     // Autoflush
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisplay* nodep) override {
         startStatement(nodep);
         iterateChildren(nodep);
         m_stmtp = nullptr;
@@ -356,7 +356,7 @@ private:
             }
         }
     }
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         iterateChildren(nodep);
         // Any strings sent to a display must be var of string data type,
         // to avoid passing a pointer to a temporary.
@@ -370,8 +370,8 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar*) override {}  // Don't hit varrefs under vars
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Don't hit varrefs under vars
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS

src/V3ProtectLib.cpp

@@ -64,7 +64,7 @@ private:
     bool m_hasClk = false;  // True if the top module has sequential logic
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         m_vfilep
             = new AstVFile{nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".sv"};
         nodep->addFilesp(m_vfilep);
@@ -74,7 +74,7 @@ private:
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         if (!nodep->isTop()) {
             return;
         } else {
@@ -422,7 +422,7 @@ private:
         m_cfilep->tblockp(txtp);
     }
 
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (!nodep->isIO()) return;
         if (nodep->direction() == VDirection::INPUT) {
             if (nodep->isUsedClock() || nodep->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
@@ -439,7 +439,7 @@ private:
         }
     }
 
-    virtual void visit(AstNode*) override {}
+    void visit(AstNode*) override {}
 
     string cInputConnection(AstVar* varp) {
         return V3Task::assignDpiToInternal("handlep__V->" + varp->name(), varp);

src/V3Randomize.cpp

@@ -82,7 +82,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         iterateChildren(nodep);
         if (nodep->extendsp()) {
             // Save pointer to derived class
@@ -90,7 +90,7 @@ private:
             m_baseToDerivedMap[basep].insert(nodep);
         }
     }
-    virtual void visit(AstMethodCall* nodep) override {
+    void visit(AstMethodCall* nodep) override {
         iterateChildren(nodep);
         if (nodep->name() != "randomize") return;
         if (const AstClassRefDType* const classRefp
@@ -100,7 +100,7 @@ private:
             markMembers(classp);
         }
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -108,7 +108,7 @@ public:
         iterate(nodep);
         markAllDerived();
     }
-    virtual ~RandomizeMarkVisitor() override = default;
+    ~RandomizeMarkVisitor() override = default;
 };
 
 //######################################################################
@@ -199,7 +199,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         iterateChildren(nodep);
         if (!nodep->user1()) return;  // Doesn't need randomize, or already processed
         UINFO(9, "Define randomize() for " << nodep << endl);
@@ -241,12 +241,12 @@ private:
         }
         nodep->user1(false);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit RandomizeVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~RandomizeVisitor() override = default;
+    ~RandomizeVisitor() override = default;
 };
 
 //######################################################################

src/V3Reloop.cpp

@@ -151,7 +151,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         VL_RESTORER(m_cfuncp);
         {
             m_cfuncp = nodep;
@@ -159,7 +159,7 @@ private:
             mergeEnd();  // Finish last pending merge, if any
         }
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         if (!m_cfuncp) return;
 
         // Left select WordSel or ArraySel
@@ -250,14 +250,14 @@ private:
         UINFO(9, "Start merge i=" << lindex << " o=" << m_mgOffset << nodep << endl);
     }
     //--------------------
-    virtual void visit(AstVar*) override {}  // Accelerate
-    virtual void visit(AstNodeMath*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstVar*) override {}  // Accelerate
+    void visit(AstNodeMath*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit ReloopVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~ReloopVisitor() override {
+    ~ReloopVisitor() override {
         V3Stats::addStat("Optimizations, Reloops", m_statReloops);
         V3Stats::addStat("Optimizations, Reloop iterations", m_statReItems);
     }

src/V3Scope.cpp

@@ -81,7 +81,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         AstNodeModule* const modp = nodep->topModulep();
         if (!modp) {
             nodep->v3error("No top level module found");
@@ -93,7 +93,7 @@ private:
         iterate(modp);
         cleanupVarRefs();
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         // Create required blocks and add to module
         string scopename;
         if (!m_aboveScopep) {
@@ -144,7 +144,7 @@ private:
 
         // ***Note m_scopep is passed back to the caller of the routine (above)
     }
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         // Create required blocks and add to module
         VL_RESTORER(m_scopep);
         VL_RESTORER(m_aboveCellp);
@@ -177,13 +177,13 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstCellInline* nodep) override {  //
+    void visit(AstCellInline* nodep) override {  //
         nodep->scopep(m_scopep);
     }
-    virtual void visit(AstActive* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstActive* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc("Actives now made after scoping");
     }
-    virtual void visit(AstNodeProcedure* nodep) override {
+    void visit(AstNodeProcedure* nodep) override {
         // Add to list of blocks under this scope
         UINFO(4, "    Move " << nodep << endl);
         AstNode* const clonep = nodep->cloneTree(false);
@@ -191,7 +191,7 @@ private:
         m_scopep->addActivep(clonep);
         iterateChildren(clonep);  // We iterate under the *clone*
     }
-    virtual void visit(AstAssignAlias* nodep) override {
+    void visit(AstAssignAlias* nodep) override {
         // Add to list of blocks under this scope
         UINFO(4, "    Move " << nodep << endl);
         AstNode* const clonep = nodep->cloneTree(false);
@@ -199,7 +199,7 @@ private:
         m_scopep->addActivep(clonep);
         iterateChildren(clonep);  // We iterate under the *clone*
     }
-    virtual void visit(AstAssignVarScope* nodep) override {
+    void visit(AstAssignVarScope* nodep) override {
         // Copy under the scope but don't recurse
         UINFO(4, "    Move " << nodep << endl);
         AstNode* const clonep = nodep->cloneTree(false);
@@ -207,7 +207,7 @@ private:
         m_scopep->addActivep(clonep);
         iterateChildren(clonep);  // We iterate under the *clone*
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         // Add to list of blocks under this scope
         UINFO(4, "    Move " << nodep << endl);
         AstNode* const clonep = nodep->cloneTree(false);
@@ -215,7 +215,7 @@ private:
         m_scopep->addActivep(clonep);
         iterateChildren(clonep);  // We iterate under the *clone*
     }
-    virtual void visit(AstAlwaysPublic* nodep) override {
+    void visit(AstAlwaysPublic* nodep) override {
         // Add to list of blocks under this scope
         UINFO(4, "    Move " << nodep << endl);
         AstNode* const clonep = nodep->cloneTree(false);
@@ -223,7 +223,7 @@ private:
         m_scopep->addActivep(clonep);
         iterateChildren(clonep);  // We iterate under the *clone*
     }
-    virtual void visit(AstCoverToggle* nodep) override {
+    void visit(AstCoverToggle* nodep) override {
         // Add to list of blocks under this scope
         UINFO(4, "    Move " << nodep << endl);
         AstNode* const clonep = nodep->cloneTree(false);
@@ -231,7 +231,7 @@ private:
         m_scopep->addActivep(clonep);
         iterateChildren(clonep);  // We iterate under the *clone*
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         // Add to list of blocks under this scope
         UINFO(4, "    CFUNC " << nodep << endl);
         AstCFunc* const clonep = nodep->cloneTree(false);
@@ -241,7 +241,7 @@ private:
         // We iterate under the *clone*
         iterateChildren(clonep);
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         // Add to list of blocks under this scope
         UINFO(4, "    FTASK " << nodep << endl);
         AstNodeFTask* clonep;
@@ -257,7 +257,7 @@ private:
         // We iterate under the *clone*
         iterateChildren(clonep);
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         // Make new scope variable
         if (!nodep->user1p()) {
             AstVarScope* const varscp = new AstVarScope(nodep->fileline(), m_scopep, nodep);
@@ -275,7 +275,7 @@ private:
             m_scopep->addVarp(varscp);
         }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // VarRef needs to point to VarScope
         // Make sure variable has made user1p.
         UASSERT_OBJ(nodep->varp(), nodep, "Unlinked");
@@ -289,7 +289,7 @@ private:
             m_varRefScopes.emplace(nodep, m_scopep);
         }
     }
-    virtual void visit(AstScopeName* nodep) override {
+    void visit(AstScopeName* nodep) override {
         // If there's a %m in the display text, we add a special node that will contain the name()
         const string prefix = std::string{"__DOT__"} + m_scopep->name();
         // TOP and above will be the user's name().
@@ -305,17 +305,17 @@ private:
         if (afterp) nodep->scopeEntrp(afterp);
         iterateChildren(nodep);
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         // Scope that was made by this module for different cell;
         // Want to ignore blocks under it, so just do nothing
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit ScopeVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~ScopeVisitor() override = default;
+    ~ScopeVisitor() override = default;
 };
 
 //######################################################################
@@ -330,7 +330,7 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         // Want to ignore blocks under it
         VL_RESTORER(m_scopep);
         {
@@ -351,20 +351,20 @@ private:
         }
     }
 
-    virtual void visit(AstNodeProcedure* nodep) override { movedDeleteOrIterate(nodep); }
-    virtual void visit(AstAssignAlias* nodep) override { movedDeleteOrIterate(nodep); }
-    virtual void visit(AstAssignVarScope* nodep) override { movedDeleteOrIterate(nodep); }
-    virtual void visit(AstAssignW* nodep) override { movedDeleteOrIterate(nodep); }
-    virtual void visit(AstAlwaysPublic* nodep) override { movedDeleteOrIterate(nodep); }
-    virtual void visit(AstCoverToggle* nodep) override { movedDeleteOrIterate(nodep); }
-    virtual void visit(AstNodeFTask* nodep) override { movedDeleteOrIterate(nodep); }
-    virtual void visit(AstCFunc* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstNodeProcedure* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstAssignAlias* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstAssignVarScope* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstAssignW* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstAlwaysPublic* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstCoverToggle* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstNodeFTask* nodep) override { movedDeleteOrIterate(nodep); }
+    void visit(AstCFunc* nodep) override { movedDeleteOrIterate(nodep); }
 
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         // The crossrefs are dealt with in V3LinkDot
         nodep->varp(nullptr);
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         // The crossrefs are dealt with in V3LinkDot
         UINFO(9, "   Old pkg-taskref " << nodep << endl);
         if (nodep->classOrPackagep()) {
@@ -380,7 +380,7 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstModportFTaskRef* nodep) override {
+    void visit(AstModportFTaskRef* nodep) override {
         // The modport persists only for xml dump
         // The crossrefs are dealt with in V3LinkDot
         nodep->ftaskp(nullptr);
@@ -388,12 +388,12 @@ private:
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit ScopeCleanupVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~ScopeCleanupVisitor() override = default;
+    ~ScopeCleanupVisitor() override = default;
 };
 
 //######################################################################

src/V3Simulate.h

@@ -397,15 +397,15 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         if (jumpingOver(nodep)) return;
         checkNodeInfo(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstSenTree* nodep) override {
+    void visit(AstSenTree* nodep) override {
         // Sensitivities aren't inputs per se; we'll keep our tree under the same sens.
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (jumpingOver(nodep)) return;
         if (!optimizable()) return;  // Accelerate
         UASSERT_OBJ(nodep->varp(), nodep, "Unlinked");
@@ -473,7 +473,7 @@ private:
             }
         }
     }
-    virtual void visit(AstVarXRef* nodep) override {
+    void visit(AstVarXRef* nodep) override {
         if (jumpingOver(nodep)) return;
         if (m_scoped) {
             badNodeType(nodep);
@@ -483,7 +483,7 @@ private:
                                     "allowed in constant functions");
         }
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         if (jumpingOver(nodep)) return;
         if (!m_params) {
             badNodeType(nodep);
@@ -503,7 +503,7 @@ private:
         checkNodeInfo(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         if (jumpingOver(nodep)) return;
         UINFO(5, "   IF " << nodep << endl);
         checkNodeInfo(nodep);
@@ -520,15 +520,15 @@ private:
             }
         }
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         checkNodeInfo(nodep);
         if (!m_checkOnly && optimizable()) newValue(nodep, nodep);
     }
-    virtual void visit(AstInitArray* nodep) override {
+    void visit(AstInitArray* nodep) override {
         checkNodeInfo(nodep);
         if (!m_checkOnly && optimizable()) newValue(nodep, nodep);
     }
-    virtual void visit(AstEnumItemRef* nodep) override {
+    void visit(AstEnumItemRef* nodep) override {
         checkNodeInfo(nodep);
         UASSERT_OBJ(nodep->itemp(), nodep, "Not linked");
         if (!m_checkOnly && optimizable()) {
@@ -541,7 +541,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeUniop* nodep) override {
+    void visit(AstNodeUniop* nodep) override {
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
         iterateChildren(nodep);
@@ -549,7 +549,7 @@ private:
             nodep->numberOperate(newConst(nodep)->num(), fetchConst(nodep->lhsp())->num());
         }
     }
-    virtual void visit(AstNodeBiop* nodep) override {
+    void visit(AstNodeBiop* nodep) override {
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
         iterateChildren(nodep);
@@ -558,7 +558,7 @@ private:
                                  fetchConst(nodep->rhsp())->num());
         }
     }
-    virtual void visit(AstNodeTriop* nodep) override {
+    void visit(AstNodeTriop* nodep) override {
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
         iterateChildren(nodep);
@@ -568,7 +568,7 @@ private:
                                  fetchConst(nodep->thsp())->num());
         }
     }
-    virtual void visit(AstNodeQuadop* nodep) override {
+    void visit(AstNodeQuadop* nodep) override {
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
         iterateChildren(nodep);
@@ -579,7 +579,7 @@ private:
                                  fetchConst(nodep->fhsp())->num());
         }
     }
-    virtual void visit(AstLogAnd* nodep) override {
+    void visit(AstLogAnd* nodep) override {
         // Need to short circuit
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
@@ -597,7 +597,7 @@ private:
             }
         }
     }
-    virtual void visit(AstLogOr* nodep) override {
+    void visit(AstLogOr* nodep) override {
         // Need to short circuit
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
@@ -615,7 +615,7 @@ private:
             }
         }
     }
-    virtual void visit(AstLogIf* nodep) override {
+    void visit(AstLogIf* nodep) override {
         // Need to short circuit, same as (!A || B)
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
@@ -635,7 +635,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeCond* nodep) override {
+    void visit(AstNodeCond* nodep) override {
         // 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.
@@ -755,7 +755,7 @@ private:
         }
     }
 
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         if (jumpingOver(nodep)) return;
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
@@ -795,7 +795,7 @@ private:
         }
         m_inDlyAssign = false;
     }
-    virtual void visit(AstArraySel* nodep) override {
+    void visit(AstArraySel* nodep) override {
         checkNodeInfo(nodep);
         iterateChildren(nodep);
         if (AstInitArray* const initp = VN_CAST(fetchValueNull(nodep->fromp()), InitArray)) {
@@ -812,11 +812,11 @@ private:
             clearOptimizable(nodep, "Array select of non-array");
         }
     }
-    virtual void visit(AstBegin* nodep) override {
+    void visit(AstBegin* nodep) override {
         checkNodeInfo(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstNodeCase* nodep) override {
+    void visit(AstNodeCase* nodep) override {
         if (jumpingOver(nodep)) return;
         UINFO(5, "   CASE " << nodep << endl);
         checkNodeInfo(nodep);
@@ -854,20 +854,20 @@ private:
         }
     }
 
-    virtual void visit(AstCaseItem* nodep) override {
+    void visit(AstCaseItem* nodep) override {
         // Real handling is in AstNodeCase
         if (jumpingOver(nodep)) return;
         checkNodeInfo(nodep);
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstComment*) override {}
+    void visit(AstComment*) override {}
 
-    virtual void visit(AstJumpBlock* nodep) override {
+    void visit(AstJumpBlock* nodep) override {
         if (jumpingOver(nodep)) return;
         iterateChildren(nodep);
     }
-    virtual void visit(AstJumpGo* nodep) override {
+    void visit(AstJumpGo* nodep) override {
         if (jumpingOver(nodep)) return;
         checkNodeInfo(nodep);
         if (!m_checkOnly) {
@@ -875,7 +875,7 @@ private:
             m_jumpp = nodep;
         }
     }
-    virtual void visit(AstJumpLabel* nodep) override {
+    void visit(AstJumpLabel* nodep) override {
         // This only supports forward jumps. That's all we make at present,
         // AstJumpGo::broken uses brokeExistsBelow() to check this.
         if (jumpingOver(nodep)) return;
@@ -886,7 +886,7 @@ private:
             m_jumpp = nullptr;
         }
     }
-    virtual void visit(AstStop* nodep) override {
+    void visit(AstStop* nodep) override {
         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
@@ -897,7 +897,7 @@ private:
         checkNodeInfo(nodep);
     }
 
-    virtual void visit(AstNodeFor* nodep) override {
+    void visit(AstNodeFor* nodep) override {
         // Doing lots of Whiles is slow, so only for parameters
         UINFO(5, "   FOR " << nodep << endl);
         if (!m_params) {
@@ -929,7 +929,7 @@ private:
         }
     }
 
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         // Doing lots of Whiles is slow, so only for parameters
         if (jumpingOver(nodep)) return;
         UINFO(5, "   WHILE " << nodep << endl);
@@ -969,7 +969,7 @@ private:
         }
     }
 
-    virtual void visit(AstFuncRef* nodep) override {
+    void visit(AstFuncRef* nodep) override {
         if (jumpingOver(nodep)) return;
         if (!optimizable()) return;  // Accelerate
         UINFO(5, "   FUNCREF " << nodep << endl);
@@ -1041,7 +1041,7 @@ private:
         }
     }
 
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (jumpingOver(nodep)) return;
         if (!m_params) {
             badNodeType(nodep);
@@ -1049,12 +1049,12 @@ private:
         }
     }
 
-    virtual void visit(AstScopeName* nodep) override {
+    void visit(AstScopeName* nodep) override {
         if (jumpingOver(nodep)) return;
         // Ignore
     }
 
-    virtual void visit(AstSFormatF* nodep) override {
+    void visit(AstSFormatF* nodep) override {
         if (jumpingOver(nodep)) return;
         if (!optimizable()) return;  // Accelerate
         checkNodeInfo(nodep);
@@ -1108,7 +1108,7 @@ private:
         }
     }
 
-    virtual void visit(AstDisplay* nodep) override {
+    void visit(AstDisplay* nodep) override {
         if (jumpingOver(nodep)) return;
         if (!optimizable()) return;  // Accelerate
         // We ignore isPredictOptimizable as $display is often in constant
@@ -1133,7 +1133,7 @@ private:
     // These types are definitely not reducible
     //   AstCoverInc, AstFinish,
     //   AstRand, AstTime, AstUCFunc, AstCCall, AstCStmt, AstUCStmt
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         if (jumpingOver(nodep)) return;
         badNodeType(nodep);
     }
@@ -1188,7 +1188,7 @@ public:
         setMode(false /*scoped*/, false /*checking*/, true /*params*/);
         mainGuts(nodep);
     }
-    virtual ~SimulateVisitor() override {
+    ~SimulateVisitor() override {
         for (const auto& pair : m_constps) {
             for (AstConst* const constp : pair.second) { delete constp; }
         }

src/V3Slice.cpp

@@ -128,7 +128,7 @@ class SliceVisitor final : public VNVisitor {
         return newp;
     }
 
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         // Called recursively on newly created assignments
         if (!nodep->user1() && !VN_IS(nodep, AssignAlias)) {
             nodep->user1(true);
@@ -162,7 +162,7 @@ class SliceVisitor final : public VNVisitor {
         }
     }
 
-    virtual void visit(AstInitArray* nodep) override {
+    void visit(AstInitArray* nodep) override {
         UASSERT_OBJ(!m_assignp, nodep, "Array initialization should have been removed earlier");
     }
 
@@ -221,17 +221,17 @@ class SliceVisitor final : public VNVisitor {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstEq* nodep) override { expandBiOp(nodep); }
-    virtual void visit(AstNeq* nodep) override { expandBiOp(nodep); }
-    virtual void visit(AstEqCase* nodep) override { expandBiOp(nodep); }
-    virtual void visit(AstNeqCase* nodep) override { expandBiOp(nodep); }
+    void visit(AstEq* nodep) override { expandBiOp(nodep); }
+    void visit(AstNeq* nodep) override { expandBiOp(nodep); }
+    void visit(AstEqCase* nodep) override { expandBiOp(nodep); }
+    void visit(AstNeqCase* nodep) override { expandBiOp(nodep); }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit SliceVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~SliceVisitor() override = default;
+    ~SliceVisitor() override = default;
 };
 
 //######################################################################

src/V3Split.cpp

@@ -103,14 +103,12 @@ protected:
     SplitNodeVertex(V3Graph* graphp, AstNode* nodep)
         : V3GraphVertex{graphp}
         , m_nodep{nodep} {}
-    virtual ~SplitNodeVertex() override = default;
+    ~SplitNodeVertex() override = default;
     // ACCESSORS
     // Do not make accessor for nodep(),  It may change due to
     // reordering a lower block, but we don't repair it
-    virtual string name() const override {
-        return cvtToHex(m_nodep) + ' ' + m_nodep->prettyTypeName();
-    }
-    virtual FileLine* fileline() const override { return nodep()->fileline(); }
+    string name() const override { return cvtToHex(m_nodep) + ' ' + m_nodep->prettyTypeName(); }
+    FileLine* fileline() const override { return nodep()->fileline(); }
 
 public:
     virtual AstNode* nodep() const { return m_nodep; }
@@ -120,34 +118,34 @@ class SplitPliVertex final : public SplitNodeVertex {
 public:
     explicit SplitPliVertex(V3Graph* graphp, AstNode* nodep)
         : SplitNodeVertex{graphp, nodep} {}
-    virtual ~SplitPliVertex() override = default;
-    virtual string name() const override { return "*PLI*"; }
-    virtual string dotColor() const override { return "green"; }
+    ~SplitPliVertex() override = default;
+    string name() const override { return "*PLI*"; }
+    string dotColor() const override { return "green"; }
 };
 
 class SplitLogicVertex final : public SplitNodeVertex {
 public:
     SplitLogicVertex(V3Graph* graphp, AstNode* nodep)
         : SplitNodeVertex{graphp, nodep} {}
-    virtual ~SplitLogicVertex() override = default;
-    virtual string dotColor() const override { return "yellow"; }
+    ~SplitLogicVertex() override = default;
+    string dotColor() const override { return "yellow"; }
 };
 
 class SplitVarStdVertex final : public SplitNodeVertex {
 public:
     SplitVarStdVertex(V3Graph* graphp, AstNode* nodep)
         : SplitNodeVertex{graphp, nodep} {}
-    virtual ~SplitVarStdVertex() override = default;
-    virtual string dotColor() const override { return "skyblue"; }
+    ~SplitVarStdVertex() override = default;
+    string dotColor() const override { return "skyblue"; }
 };
 
 class SplitVarPostVertex final : public SplitNodeVertex {
 public:
     SplitVarPostVertex(V3Graph* graphp, AstNode* nodep)
         : SplitNodeVertex{graphp, nodep} {}
-    virtual ~SplitVarPostVertex() override = default;
-    virtual string name() const override { return string("POST ") + SplitNodeVertex::name(); }
-    virtual string dotColor() const override { return "CadetBlue"; }
+    ~SplitVarPostVertex() override = default;
+    string name() const override { return string("POST ") + SplitNodeVertex::name(); }
+    string dotColor() const override { return "CadetBlue"; }
 };
 
 //######################################################################
@@ -161,7 +159,7 @@ protected:
     SplitEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight,
               bool cutable = CUTABLE)
         : V3GraphEdge{graphp, fromp, top, weight, cutable} {}
-    virtual ~SplitEdge() override = default;
+    ~SplitEdge() override = default;
 
 public:
     // Iterator for graph functions
@@ -180,7 +178,7 @@ public:
         if (!oedgep) v3fatalSrc("Following edge of non-SplitEdge type");
         return (!oedgep->ignoreThisStep());
     }
-    virtual string dotStyle() const override {
+    string dotStyle() const override {
         return ignoreThisStep() ? "dotted" : V3GraphEdge::dotStyle();
     }
 };
@@ -190,36 +188,36 @@ class SplitPostEdge final : public SplitEdge {
 public:
     SplitPostEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {}
-    virtual ~SplitPostEdge() override = default;
-    virtual bool followScoreboard() const override { return false; }
-    virtual string dotColor() const override { return "khaki"; }
+    ~SplitPostEdge() override = default;
+    bool followScoreboard() const override { return false; }
+    string dotColor() const override { return "khaki"; }
 };
 
 class SplitLVEdge final : public SplitEdge {
 public:
     SplitLVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {}
-    virtual ~SplitLVEdge() override = default;
-    virtual bool followScoreboard() const override { return true; }
-    virtual string dotColor() const override { return "yellowGreen"; }
+    ~SplitLVEdge() override = default;
+    bool followScoreboard() const override { return true; }
+    string dotColor() const override { return "yellowGreen"; }
 };
 
 class SplitRVEdge final : public SplitEdge {
 public:
     SplitRVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {}
-    virtual ~SplitRVEdge() override = default;
-    virtual bool followScoreboard() const override { return true; }
-    virtual string dotColor() const override { return "green"; }
+    ~SplitRVEdge() override = default;
+    bool followScoreboard() const override { return true; }
+    string dotColor() const override { return "green"; }
 };
 
 struct SplitScorebdEdge : public SplitEdge {
 public:
     SplitScorebdEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {}
-    virtual ~SplitScorebdEdge() override = default;
-    virtual bool followScoreboard() const override { return true; }
-    virtual string dotColor() const override { return "blue"; }
+    ~SplitScorebdEdge() override = default;
+    bool followScoreboard() const override { return true; }
+    string dotColor() const override { return "blue"; }
 };
 
 struct SplitStrictEdge : public SplitEdge {
@@ -228,9 +226,9 @@ struct SplitStrictEdge : public SplitEdge {
 public:
     SplitStrictEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
         : SplitEdge{graphp, fromp, top, WEIGHT_NORMAL, NOT_CUTABLE} {}
-    virtual ~SplitStrictEdge() override = default;
-    virtual bool followScoreboard() const override { return true; }
-    virtual string dotColor() const override { return "blue"; }
+    ~SplitStrictEdge() override = default;
+    bool followScoreboard() const override { return true; }
+    string dotColor() const override { return "blue"; }
 };
 
 //######################################################################
@@ -259,7 +257,7 @@ protected:
     // CONSTRUCTORS
 public:
     SplitReorderBaseVisitor() { scoreboardClear(); }
-    virtual ~SplitReorderBaseVisitor() override = default;
+    ~SplitReorderBaseVisitor() override = default;
 
     // METHODS
 protected:
@@ -335,19 +333,19 @@ protected:
     virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) = 0;
 
     // VISITORS
-    virtual void visit(AstAlways* nodep) override = 0;
-    virtual void visit(AstNodeIf* nodep) override = 0;
+    void visit(AstAlways* nodep) override = 0;
+    void visit(AstNodeIf* nodep) override = 0;
 
     // We don't do AstNodeFor/AstWhile loops, due to the standard question
     // of what is before vs. after
 
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         m_inDly = true;
         UINFO(4, "    ASSIGNDLY " << nodep << endl);
         iterateChildren(nodep);
         m_inDly = false;
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (!m_stmtStackps.empty()) {
             AstVarScope* const vscp = nodep->varScopep();
             UASSERT_OBJ(vscp, nodep, "Not linked");
@@ -410,7 +408,7 @@ protected:
         }
     }
 
-    virtual void visit(AstJumpGo* nodep) override {
+    void visit(AstJumpGo* nodep) override {
         // 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
@@ -422,7 +420,7 @@ protected:
 
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         // **** SPECIAL default type that sets PLI_ORDERING
         if (!m_stmtStackps.empty() && !nodep->isPure()) {
             UINFO(9, "         NotSplittable " << nodep << endl);
@@ -439,11 +437,11 @@ class ReorderVisitor final : public SplitReorderBaseVisitor {
     // CONSTRUCTORS
 public:
     explicit ReorderVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~ReorderVisitor() override = default;
+    ~ReorderVisitor() override = default;
 
     // METHODS
 protected:
-    virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
+    void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
         for (SplitLogicVertex* vxp : m_stmtStackps) new SplitRVEdge(&m_graph, vxp, vstdp);
     }
 
@@ -599,7 +597,7 @@ protected:
         firstp->user3p(oldBlockUser3);
     }
 
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         UINFO(4, "   ALW   " << nodep << endl);
         if (debug() >= 9) nodep->dumpTree(cout, "   alwIn:: ");
         scoreboardClear();
@@ -607,7 +605,7 @@ protected:
         if (debug() >= 9) nodep->dumpTree(cout, "   alwOut: ");
     }
 
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         UINFO(4, "     IF " << nodep << endl);
         iterateAndNextNull(nodep->condp());
         processBlock(nodep->ifsp());
@@ -636,7 +634,7 @@ public:
     // Visit through *nodep and map each AstNodeIf within to the set of
     // colors it will participate in. Also find the whole set of colors.
     explicit IfColorVisitor(AstAlways* nodep) { iterate(nodep); }
-    virtual ~IfColorVisitor() override = default;
+    ~IfColorVisitor() override = default;
 
     // METHODS
     const ColorSet& colors() const { return m_colors; }
@@ -663,13 +661,13 @@ private:
     }
 
 protected:
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         m_ifStack.push_back(nodep);
         trackNode(nodep);
         iterateChildren(nodep);
         m_ifStack.pop_back();
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         trackNode(nodep);
         iterateChildren(nodep);
     }
@@ -701,7 +699,7 @@ public:
         UINFO(6, "  splitting always " << nodep << endl);
     }
 
-    virtual ~EmitSplitVisitor() override = default;
+    ~EmitSplitVisitor() override = default;
 
     // METHODS
     void go() {
@@ -732,7 +730,7 @@ protected:
         return new AstSplitPlaceholder(m_origAlwaysp->fileline());
     }
 
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         // Anything that's not an if/else we assume is a leaf
         // (that is, something we won't split.) Don't visit further
         // into the leaf.
@@ -754,7 +752,7 @@ protected:
         m_addAfter[color] = clonedp;
     }
 
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         const ColorSet& colors = m_ifColorp->colors(nodep);
         using CloneMap = std::unordered_map<uint32_t, AstNodeIf*>;
         CloneMap clones;
@@ -798,17 +796,17 @@ class RemovePlaceholdersVisitor final : public VNVisitor {
 
     // CONSTRUCTORS
     RemovePlaceholdersVisitor() = default;
-    virtual ~RemovePlaceholdersVisitor() override = default;
+    ~RemovePlaceholdersVisitor() override = default;
 
     // VISITORS
-    virtual void visit(AstSplitPlaceholder* nodep) override { pushDeletep(nodep->unlinkFrBack()); }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstSplitPlaceholder* nodep) override { pushDeletep(nodep->unlinkFrBack()); }
+    void visit(AstNodeIf* nodep) override {
         VL_RESTORER(m_isPure);
         m_isPure = true;
         iterateChildren(nodep);
         if (!nodep->ifsp() && !nodep->elsesp() && m_isPure) pushDeletep(nodep->unlinkFrBack());
     }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         VL_RESTORER(m_isPure);
         m_isPure = true;
         iterateChildren(nodep);
@@ -828,7 +826,7 @@ class RemovePlaceholdersVisitor final : public VNVisitor {
             }
         }
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         m_isPure &= nodep->isPure();
         iterateChildren(nodep);  // must visit regardless of m_isPure to remove placeholders
     }
@@ -875,13 +873,11 @@ public:
         }
     }
 
-    virtual ~SplitVisitor() override {
-        V3Stats::addStat("Optimizations, Split always", m_statSplits);
-    }
+    ~SplitVisitor() override { V3Stats::addStat("Optimizations, Split always", m_statSplits); }
 
     // METHODS
 protected:
-    virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
+    void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
         // Each 'if' depends on rvalues in its own conditional ONLY,
         // not rvalues in the if/else bodies.
         for (auto it = m_stmtStackps.cbegin(); it != m_stmtStackps.cend(); ++it) {
@@ -956,7 +952,7 @@ protected:
         if (debug() >= 9) m_graph.dumpDotFilePrefixed("splitg_colored", false);
     }
 
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         // build the scoreboard
         scoreboardClear();
         scanBlock(nodep->bodysp());
@@ -988,7 +984,7 @@ protected:
             emitSplit.go();
         }
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         UINFO(4, "     IF " << nodep << endl);
         m_curIfConditional = nodep;
         iterateAndNextNull(nodep->condp());

src/V3SplitAs.cpp

@@ -49,17 +49,17 @@ private:
     AstVarScope* m_splitVscp = nullptr;  // Variable we want to split
 
     // METHODS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (nodep->access().isWriteOrRW() && !m_splitVscp && nodep->varp()->attrIsolateAssign()) {
             m_splitVscp = nodep->varScopep();
         }
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit SplitAsFindVisitor(AstAlways* nodep) { iterate(nodep); }
-    virtual ~SplitAsFindVisitor() override = default;
+    ~SplitAsFindVisitor() override = default;
     // METHODS
     AstVarScope* splitVscp() const { return m_splitVscp; }
 };
@@ -76,7 +76,7 @@ private:
     bool m_matches = false;  // Statement below has matching lvalue reference
 
     // METHODS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (nodep->access().isWriteOrRW()) {
             if (nodep->varScopep() == m_splitVscp) {
                 UINFO(6, "       CL VAR " << nodep << endl);
@@ -84,7 +84,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (!nodep->isStatement()) {
             iterateChildren(nodep);
             return;
@@ -110,7 +110,7 @@ private:
         m_keepStmt = oldKeep || m_keepStmt;
         UINFO(9, "     upKeep=" << m_keepStmt << " STMT " << nodep << endl);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -119,7 +119,7 @@ public:
         , m_modeMatch{modeMatch} {
         iterate(nodep);
     }
-    virtual ~SplitAsCleanVisitor() override = default;
+    ~SplitAsCleanVisitor() override = default;
 };
 
 //######################################################################
@@ -154,7 +154,7 @@ private:
         }
     }
 
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         // Are there any lvalue references below this?
         // There could be more than one.  So, we process the first one found first.
         const AstVarScope* lastSplitVscp = nullptr;
@@ -179,13 +179,13 @@ private:
     }
 
     // Speedup; no always under math
-    virtual void visit(AstNodeMath*) override {}
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeMath*) override {}
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit SplitAsVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~SplitAsVisitor() override {
+    ~SplitAsVisitor() override {
         V3Stats::addStat("Optimizations, isolate_assignments blocks", m_statSplits);
     }
 };

src/V3SplitVar.cpp

@@ -362,10 +362,10 @@ public:
     void remove(AstNode* nodep) {
         struct Visitor : public VNVisitor {
             RefsInModule& m_parent;
-            virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
-            virtual void visit(AstVar* nodep) override { m_parent.m_vars.erase(nodep); }
-            virtual void visit(AstVarRef* nodep) override { m_parent.m_refs.erase(nodep); }
-            virtual void visit(AstSel* nodep) override {
+            void visit(AstNode* nodep) override { iterateChildren(nodep); }
+            void visit(AstVar* nodep) override { m_parent.m_vars.erase(nodep); }
+            void visit(AstVarRef* nodep) override { m_parent.m_refs.erase(nodep); }
+            void visit(AstSel* nodep) override {
                 m_parent.m_sels.erase(nodep);
                 iterateChildren(nodep);
             }
@@ -456,8 +456,8 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
         return refp;
     }
 
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeModule* nodep) override {
         UINFO(4, "Start checking " << nodep->prettyNameQ() << "\n");
         if (!VN_IS(nodep, Module)) {
             UINFO(4, "Skip " << nodep->prettyNameQ() << "\n");
@@ -471,9 +471,9 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
         split();
         m_modp = nullptr;
     }
-    virtual void visit(AstNodeStmt* nodep) override { setContextAndIterateChildren(nodep); }
-    virtual void visit(AstCell* nodep) override { setContextAndIterateChildren(nodep); }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstNodeStmt* nodep) override { setContextAndIterateChildren(nodep); }
+    void visit(AstCell* nodep) override { setContextAndIterateChildren(nodep); }
+    void visit(AstAlways* nodep) override {
         if (nodep->sensesp()) {  // When visiting sensitivity list, always is the context
             setContextAndIterate(nodep, nodep->sensesp());
         }
@@ -481,7 +481,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             iterate(bodysp);
         }
     };
-    virtual void visit(AstAlwaysPublic* nodep) override {
+    void visit(AstAlwaysPublic* nodep) override {
         if (nodep->sensesp()) {  // When visiting sensitivity list, always is the context
             setContextAndIterate(nodep, nodep->sensesp());
         }
@@ -489,7 +489,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             iterate(bodysp);
         }
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         VL_RESTORER(m_contextp);
         {
             m_contextp = nodep;
@@ -524,7 +524,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             }
         }
     }
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         UINFO(5, nodep->modVarp()->prettyNameQ() << " pin \n");
         AstNode* const exprp = nodep->exprp();
         if (!exprp) return;  // Not connected pin
@@ -538,7 +538,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             m_foundTargetVar.clear();
         }
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         UASSERT_OBJ(!m_inFTask, nodep, "Nested func/task");
         if (!cannotSplitTaskReason(nodep)) {
             m_inFTask = nodep;
@@ -546,7 +546,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             m_inFTask = nullptr;
         }
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (!nodep->attrSplitVar()) return;  // Nothing to do
         if (!cannotSplitReason(nodep)) {
             m_refs.registerVar(nodep);
@@ -554,18 +554,18 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
         }
         m_refsForPackedSplit[m_modp].add(nodep);
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (!nodep->varp()->attrSplitVar()) return;  // Nothing to do
         if (m_refs.tryAdd(m_contextp, nodep, m_inFTask)) {
             m_foundTargetVar.insert(nodep->varp());
         }
         m_refsForPackedSplit[m_modp].add(nodep);
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         if (VN_IS(nodep->fromp(), VarRef)) m_refsForPackedSplit[m_modp].add(nodep);
         iterateChildren(nodep);
     }
-    virtual void visit(AstArraySel* nodep) override {
+    void visit(AstArraySel* nodep) override {
         if (AstVarRef* const refp = isTargetVref(nodep->fromp())) {
             const AstConst* const indexp = VN_CAST(nodep->bitp(), Const);
             if (indexp) {  // OK
@@ -585,7 +585,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstSliceSel* nodep) override {
+    void visit(AstSliceSel* nodep) override {
         if (AstVarRef* const refp = isTargetVref(nodep->fromp())) {
             const AstUnpackArrayDType* const dtypep
                 = VN_AS(refp->varp()->dtypep()->skipRefp(), UnpackArrayDType);
@@ -966,10 +966,10 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
     int m_numSplit = 0;  // Total number of split variables
     // key:variable to be split. value:location where the variable is referenced.
     std::map<AstVar*, PackedVarRef, AstNodeComparator> m_refs;
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         if (!cannotSplitTaskReason(nodep)) iterateChildren(nodep);
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         if (!nodep->attrSplitVar()) return;  // Nothing to do
         if (const char* const reason = cannotSplitReason(nodep, true)) {
             warnNoSplit(nodep, nodep, reason);
@@ -979,7 +979,7 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             if (inserted) UINFO(3, nodep->prettyNameQ() << " is added to candidate list.\n");
         }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         AstVar* const varp = nodep->varp();
         visit(varp);
         const auto refit = m_refs.find(varp);
@@ -993,7 +993,7 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
         UINFO(5, varp->prettyName()
                      << " Entire bit of [" << basicp->lo() << "+:" << varp->width() << "] \n");
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         const AstVarRef* const vrefp = VN_CAST(nodep->fromp(), VarRef);
         if (!vrefp) {
             iterateChildren(nodep);
@@ -1032,7 +1032,7 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
     // Extract necessary bit range from a newly created variable to meet ref
     static AstNode* extractBits(const PackedVarRefEntry& ref, const SplitNewVar& var,

src/V3Stats.cpp

@@ -76,7 +76,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         allNodes(nodep);
         if (!m_fast) {
             // Count all CFuncs below this module
@@ -85,7 +85,7 @@ private:
         // Else we recursively trace fast CFuncs from the top _eval
         // func, see visit(AstNetlist*)
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         allNodes(nodep);
         iterateChildrenConst(nodep);
         if (m_counting && nodep->dtypep()) {
@@ -111,7 +111,7 @@ private:
             }
         }
     }
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         allNodes(nodep);
         iterateChildrenConst(nodep);
         if (m_counting) {
@@ -120,7 +120,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeIf* nodep) override {
+    void visit(AstNodeIf* nodep) override {
         UINFO(4, "   IF i=" << m_instrs << " " << nodep << endl);
         allNodes(nodep);
         // Condition is part of cost allocated to PREVIOUS block
@@ -166,9 +166,9 @@ private:
         }
     }
     // While's we assume evaluate once.
-    // virtual void visit(AstWhile* nodep) override {
+    //  void visit(AstWhile* nodep) override {
 
-    virtual void visit(AstNodeCCall* nodep) override {
+    void visit(AstNodeCCall* nodep) override {
         allNodes(nodep);
         iterateChildrenConst(nodep);
         if (m_fast && !nodep->funcp()->entryPoint()) {
@@ -177,7 +177,7 @@ private:
             iterate(nodep->funcp());
         }
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         if (m_fast) {
             if (!m_tracingCall && !nodep->entryPoint()) return;
             m_tracingCall = false;
@@ -189,11 +189,11 @@ private:
             iterateChildrenConst(nodep);
         }
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         allNodes(nodep);
         iterateChildrenConst(nodep);
     }
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         if (m_fast && nodep->evalp()) {
             m_instrs = 0;
             m_counting = true;
@@ -219,7 +219,7 @@ public:
         // Process
         iterate(nodep);
     }
-    virtual ~StatsVisitor() override {
+    ~StatsVisitor() override {
         // Done. Publish statistics
         V3Stats::addStat(m_stage, "Instruction count, TOTAL", m_statInstr);
         V3Stats::addStat(m_stage, "Instruction count, fast critical", m_statInstrFast);

src/V3Subst.cpp

@@ -189,7 +189,7 @@ private:
         return reinterpret_cast<SubstVarEntry*>(nodep->varp()->user1p());  // Might be nullptr
     }
     // VISITORS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         const SubstVarEntry* const entryp = findEntryp(nodep);
         if (entryp) {
             // Don't sweat it.  We assign a new temp variable for every new assignment,
@@ -204,8 +204,8 @@ private:
             }
         }
     }
-    virtual void visit(AstConst*) override {}  // Accelerate
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstConst*) override {}  // Accelerate
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -214,7 +214,7 @@ public:
         UINFO(9, "        SubstUseVisitor " << origStep << " " << nodep << endl);
         iterate(nodep);
     }
-    virtual ~SubstUseVisitor() override = default;
+    ~SubstUseVisitor() override = default;
     // METHODS
     bool ok() const { return m_ok; }
 };
@@ -258,7 +258,7 @@ private:
     inline bool isSubstVar(AstVar* nodep) { return nodep->isStatementTemp() && !nodep->noSubst(); }
 
     // VISITORS
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         m_ops = 0;
         m_assignStep++;
         iterateAndNextNull(nodep->rhsp());
@@ -304,7 +304,7 @@ private:
         VL_DO_DANGLING(pushDeletep(nodep), nodep);
         ++m_statSubsts;
     }
-    virtual void visit(AstWordSel* nodep) override {
+    void visit(AstWordSel* nodep) override {
         iterate(nodep->rhsp());
         AstVarRef* const varrefp = VN_CAST(nodep->lhsp(), VarRef);
         const AstConst* const constp = VN_CAST(nodep->rhsp(), Const);
@@ -329,7 +329,7 @@ private:
             iterate(nodep->lhsp());
         }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         // Any variable
         if (nodep->access().isWriteOrRW()) {
             m_assignStep++;
@@ -357,16 +357,16 @@ private:
             }
         }
     }
-    virtual void visit(AstVar*) override {}
-    virtual void visit(AstConst*) override {}
-    virtual void visit(AstModule* nodep) override {
+    void visit(AstVar*) override {}
+    void visit(AstConst*) override {}
+    void visit(AstModule* nodep) override {
         ++m_ops;
         if (!nodep->isSubstOptimizable()) m_ops = SUBST_MAX_OPS_NA;
         iterateChildren(nodep);
         // Reduce peak memory usage by reclaiming the edited AstNodes
         doDeletes();
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         m_ops++;
         if (!nodep->isSubstOptimizable()) m_ops = SUBST_MAX_OPS_NA;
         iterateChildren(nodep);
@@ -375,7 +375,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit SubstVisitor(AstNode* nodep) { iterate(nodep); }
-    virtual ~SubstVisitor() override {
+    ~SubstVisitor() override {
         V3Stats::addStat("Optimizations, Substituted temps", m_statSubsts);
         for (SubstVarEntry* ip : m_entryps) {
             ip->deleteUnusedAssign();

src/V3TSP.cpp

@@ -61,7 +61,7 @@ public:
     TspVertexTmpl(V3Graph* graphp, const T_Key& k)
         : V3GraphVertex{graphp}
         , m_key{k} {}
-    virtual ~TspVertexTmpl() override = default;
+    ~TspVertexTmpl() override = default;
     const T_Key& key() const { return m_key; }
 
 private:
@@ -84,7 +84,7 @@ public:
     // CONSTRUCTORS
     TspGraphTmpl()
         : V3Graph{} {}
-    virtual ~TspGraphTmpl() override = default;
+    ~TspGraphTmpl() override = default;
 
     // METHODS
     void addVertex(const T_Key& key) {
@@ -542,8 +542,8 @@ public:
         : m_xpos{xpos}
         , m_ypos{ypos}
         , m_serial{++s_serialNext} {}
-    virtual ~TspTestState() override = default;
-    virtual int cost(const TspStateBase* otherp) const override {
+    ~TspTestState() override = default;
+    int cost(const TspStateBase* otherp) const override {
         return cost(dynamic_cast<const TspTestState*>(otherp));
     }
     static unsigned diff(unsigned a, unsigned b) {

src/V3Table.cpp

@@ -59,12 +59,12 @@ class TableSimulateVisitor final : public SimulateVisitor {
 
 public:
     ///< Call other-this function on all new var references
-    virtual void varRefCb(AstVarRef* nodep) override;
+    void varRefCb(AstVarRef* nodep) override;
 
     // CONSTRUCTORS
     explicit TableSimulateVisitor(TableVisitor* cbthis)
         : m_cbthis{cbthis} {}
-    virtual ~TableSimulateVisitor() override = default;
+    ~TableSimulateVisitor() override = default;
 };
 
 //######################################################################
@@ -379,8 +379,8 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         VL_RESTORER(m_modTables);
         {
@@ -389,20 +389,20 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UINFO(4, " SCOPE " << nodep << endl);
         m_scopep = nodep;
         iterateChildren(nodep);
         m_scopep = nullptr;
     }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         UINFO(4, "  ALWAYS  " << nodep << endl);
         if (treeTest(nodep)) {
             // Well, then, I'll be a memory hog.
             replaceWithTable(nodep);
         }
     }
-    virtual void visit(AstNodeAssign* nodep) override {
+    void visit(AstNodeAssign* nodep) override {
         // It's nearly impossible to have a large enough assign to make this worthwhile
         // For now we won't bother.
         // Accelerated: no iterate
@@ -411,7 +411,7 @@ private:
 public:
     // CONSTRUCTORS
     explicit TableVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~TableVisitor() override {  //
+    ~TableVisitor() override {  //
         V3Stats::addStat("Optimizations, Tables created", m_statTablesCre);
     }
 };

src/V3Task.cpp

@@ -47,7 +47,7 @@ class TaskBaseVertex VL_NOT_FINAL : public V3GraphVertex {
 public:
     explicit TaskBaseVertex(V3Graph* graphp)
         : V3GraphVertex{graphp} {}
-    virtual ~TaskBaseVertex() override = default;
+    ~TaskBaseVertex() override = default;
     bool pure() const { return m_impurep == nullptr; }
     AstNode* impureNode() const { return m_impurep; }
     void impure(AstNode* nodep) { m_impurep = nodep; }
@@ -64,10 +64,10 @@ public:
     TaskFTaskVertex(V3Graph* graphp, AstNodeFTask* nodep)
         : TaskBaseVertex{graphp}
         , m_nodep{nodep} {}
-    virtual ~TaskFTaskVertex() override = default;
+    ~TaskFTaskVertex() override = default;
     AstNodeFTask* nodep() const { return m_nodep; }
-    virtual string name() const override { return nodep()->name(); }
-    virtual string dotColor() const override { return pure() ? "black" : "red"; }
+    string name() const override { return nodep()->name(); }
+    string dotColor() const override { return pure() ? "black" : "red"; }
     AstCFunc* cFuncp() const { return m_cFuncp; }
     void cFuncp(AstCFunc* nodep) { m_cFuncp = nodep; }
 };
@@ -77,17 +77,17 @@ class TaskCodeVertex final : public TaskBaseVertex {
 public:
     explicit TaskCodeVertex(V3Graph* graphp)
         : TaskBaseVertex{graphp} {}
-    virtual ~TaskCodeVertex() override = default;
-    virtual string name() const override { return "*CODE*"; }
-    virtual string dotColor() const override { return "green"; }
+    ~TaskCodeVertex() override = default;
+    string name() const override { return "*CODE*"; }
+    string dotColor() const override { return "green"; }
 };
 
 class TaskEdge final : public V3GraphEdge {
 public:
     TaskEdge(V3Graph* graphp, TaskBaseVertex* fromp, TaskBaseVertex* top)
         : V3GraphEdge{graphp, fromp, top, 1, false} {}
-    virtual ~TaskEdge() override = default;
-    virtual string dotLabel() const override { return "w" + cvtToStr(weight()); }
+    ~TaskEdge() override = default;
+    string dotLabel() const override { return "w" + cvtToStr(weight()); }
 };
 
 //######################################################################
@@ -166,7 +166,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         // 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.
@@ -186,12 +186,12 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         m_assignwp = nodep;
         VL_DO_DANGLING(iterateChildren(nodep), nodep);  // May delete nodep.
         m_assignwp = nullptr;
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         // Includes handling AstMethodCall, AstNew
         if (m_assignwp) {
             // Wire assigns must become always statements to deal with insertion
@@ -204,7 +204,7 @@ private:
         UASSERT_OBJ(nodep->taskp(), nodep, "Unlinked task");
         new TaskEdge(&m_callGraph, m_curVxp, getFTaskVertex(nodep->taskp()));
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         UINFO(9, "  TASK " << nodep << endl);
         {
             VL_RESTORER(m_curVxp);
@@ -221,7 +221,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstPragma* nodep) override {
+    void visit(AstPragma* nodep) override {
         if (nodep->pragType() == VPragmaType::NO_INLINE_TASK) {
             // Just mark for the next steps, and we're done with it.
             m_curVxp->noInline(true);
@@ -230,17 +230,17 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         iterateChildren(nodep);
         nodep->user4p(m_curVxp);  // Remember what task it's under
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         iterateChildren(nodep);
         if (nodep->varp()->user4u().toGraphVertex() != m_curVxp) {
             if (m_curVxp->pure() && !nodep->varp()->isXTemp()) m_curVxp->impure(nodep);
         }
     }
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         // Move initial statements into the constructor
         m_initialps.clear();
         m_ctorp = nullptr;
@@ -264,12 +264,12 @@ private:
         m_ctorp = nullptr;
         m_classp = nullptr;
     }
-    virtual void visit(AstInitialAutomatic* nodep) override {
+    void visit(AstInitialAutomatic* nodep) override {
         m_initialps.push_back(nodep);
         iterateChildren(nodep);
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -283,7 +283,7 @@ public:
         m_callGraph.removeRedundantEdgesSum(&TaskEdge::followAlwaysTrue);
         m_callGraph.dumpDotFilePrefixed("task_call");
     }
-    virtual ~TaskStateVisitor() override = default;
+    ~TaskStateVisitor() override = default;
     VL_UNCOPYABLE(TaskStateVisitor);
 };
 
@@ -1366,7 +1366,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         VL_RESTORER(m_modNCalls);
         {
@@ -1376,13 +1376,13 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         m_scopep = nodep;
         m_insStmtp = nullptr;
         iterateChildren(nodep);
         m_scopep = nullptr;
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         // Includes handling AstMethodCall, AstNew
         UASSERT_OBJ(nodep->taskp(), nodep, "Unlinked?");
         iterateIntoFTask(nodep->taskp());  // First, do hierarchical funcs
@@ -1436,7 +1436,7 @@ private:
         // Visit nodes that normal iteration won't find
         if (visitp) iterateAndNextNull(visitp);
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         UINFO(4, " visitFTask   " << nodep << endl);
         VL_RESTORER(m_insMode);
         VL_RESTORER(m_insStmtp);
@@ -1504,7 +1504,7 @@ private:
             VL_DO_DANGLING(pushDeletep(nodep), nodep);
         }
     }
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         // Special, as statements need to be put in different places
         // Preconditions insert first just before themselves (the normal
         // rule for other statement types)
@@ -1521,11 +1521,11 @@ private:
         // Done the loop
         m_insStmtp = nullptr;  // Next thing should be new statement
     }
-    virtual void visit(AstNodeFor* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstNodeFor* nodep) override {  // LCOV_EXCL_LINE
         nodep->v3fatalSrc(
             "For statements should have been converted to while statements in V3Begin.cpp");
     }
-    virtual void visit(AstNodeStmt* nodep) override {
+    void visit(AstNodeStmt* nodep) override {
         if (!nodep->isStatement()) {
             iterateChildren(nodep);
             return;
@@ -1536,7 +1536,7 @@ private:
         m_insStmtp = nullptr;  // Next thing should be new statement
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -1544,7 +1544,7 @@ public:
         : m_statep{statep} {
         iterate(nodep);
     }
-    virtual ~TaskVisitor() override = default;
+    ~TaskVisitor() override = default;
 };
 
 //######################################################################

src/V3Trace.cpp

@@ -73,20 +73,20 @@ public:
         m_activityCode = code;
         m_slow = false;
     }
-    virtual ~TraceActivityVertex() override = default;
+    ~TraceActivityVertex() override = default;
     // ACCESSORS
     AstNode* insertp() const {
         if (!m_insertp) v3fatalSrc("Null insertp; probably called on a special always/slow.");
         return m_insertp;
     }
-    virtual string name() const override {
+    string name() const override {
         if (activityAlways()) {
             return "*ALWAYS*";
         } else {
             return std::string{slow() ? "*SLOW* " : ""} + insertp()->name();
         }
     }
-    virtual string dotColor() const override { return slow() ? "yellowGreen" : "green"; }
+    string dotColor() const override { return slow() ? "yellowGreen" : "green"; }
     int32_t activityCode() const { return m_activityCode; }
     bool activityAlways() const { return activityCode() == ACTIVITY_ALWAYS; }
     bool activitySlow() const { return activityCode() == ACTIVITY_SLOW; }
@@ -104,12 +104,12 @@ public:
     TraceCFuncVertex(V3Graph* graphp, AstCFunc* nodep)
         : V3GraphVertex{graphp}
         , m_nodep{nodep} {}
-    virtual ~TraceCFuncVertex() override = default;
+    ~TraceCFuncVertex() override = default;
     // ACCESSORS
     AstCFunc* nodep() const { return m_nodep; }
-    virtual string name() const override { return nodep()->name(); }
-    virtual string dotColor() const override { return "yellow"; }
-    virtual FileLine* fileline() const override { return nodep()->fileline(); }
+    string name() const override { return nodep()->name(); }
+    string dotColor() const override { return "yellow"; }
+    FileLine* fileline() const override { return nodep()->fileline(); }
 };
 
 class TraceTraceVertex final : public V3GraphVertex {
@@ -121,12 +121,12 @@ public:
     TraceTraceVertex(V3Graph* graphp, AstTraceDecl* nodep)
         : V3GraphVertex{graphp}
         , m_nodep{nodep} {}
-    virtual ~TraceTraceVertex() override = default;
+    ~TraceTraceVertex() override = default;
     // ACCESSORS
     AstTraceDecl* nodep() const { return m_nodep; }
-    virtual string name() const override { return nodep()->name(); }
-    virtual string dotColor() const override { return "red"; }
-    virtual FileLine* fileline() const override { return nodep()->fileline(); }
+    string name() const override { return nodep()->name(); }
+    string dotColor() const override { return "red"; }
+    FileLine* fileline() const override { return nodep()->fileline(); }
     TraceTraceVertex* duplicatep() const { return m_duplicatep; }
     void duplicatep(TraceTraceVertex* dupp) {
         UASSERT_OBJ(!duplicatep(), nodep(), "Assigning duplicatep() to already duplicated node");
@@ -141,12 +141,12 @@ public:
     TraceVarVertex(V3Graph* graphp, AstVarScope* nodep)
         : V3GraphVertex{graphp}
         , m_nodep{nodep} {}
-    virtual ~TraceVarVertex() override = default;
+    ~TraceVarVertex() override = default;
     // ACCESSORS
     AstVarScope* nodep() const { return m_nodep; }
-    virtual string name() const override { return nodep()->name(); }
-    virtual string dotColor() const override { return "skyblue"; }
-    virtual FileLine* fileline() const override { return nodep()->fileline(); }
+    string name() const override { return nodep()->name(); }
+    string dotColor() const override { return "skyblue"; }
+    FileLine* fileline() const override { return nodep()->fileline(); }
 };
 
 //######################################################################
@@ -796,7 +796,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep) override {
+    void visit(AstNetlist* nodep) override {
         m_code = 1;  // Multiple TopScopes will require fixing how code#s
         // are assigned as duplicate varscopes must result in the same tracing code#.
 
@@ -811,11 +811,11 @@ private:
         // Create the trace functions and insert them into the tree
         createTraceFunctions();
     }
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         if (nodep->isTop()) m_topModp = nodep;
         iterateChildren(nodep);
     }
-    virtual void visit(AstCCall* nodep) override {
+    void visit(AstCCall* nodep) override {
         UINFO(8, "   CCALL " << nodep << endl);
         if (!m_finding && !nodep->user2()) {
             // See if there are other calls in same statement list;
@@ -834,7 +834,7 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstCFunc* nodep) override {
+    void visit(AstCFunc* nodep) override {
         UINFO(8, "   CFUNC " << nodep << endl);
         V3GraphVertex* const funcVtxp = getCFuncVertexp(nodep);
         if (!m_finding) {  // If public, we need a unique activity code to allow for sets
@@ -851,7 +851,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstTraceDecl* nodep) override {
+    void visit(AstTraceDecl* nodep) override {
         UINFO(8, "   TRACE " << nodep << endl);
         if (!m_finding) {
             V3GraphVertex* const vertexp = new TraceTraceVertex(&m_graph, nodep);
@@ -863,7 +863,7 @@ private:
             m_tracep = nullptr;
         }
     }
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (m_tracep) {
             UASSERT_OBJ(nodep->varScopep(), nodep, "No var scope?");
             UASSERT_OBJ(nodep->access().isReadOnly(), nodep, "Lvalue in trace?  Should be const.");
@@ -888,7 +888,7 @@ private:
         }
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -896,7 +896,7 @@ public:
         : m_alwaysVtxp{new TraceActivityVertex{&m_graph, TraceActivityVertex::ACTIVITY_ALWAYS}} {
         iterate(nodep);
     }
-    virtual ~TraceVisitor() override {
+    ~TraceVisitor() override {
         V3Stats::addStat("Tracing, Unique traced signals", m_statUniqSigs);
         V3Stats::addStat("Tracing, Unique trace codes", m_statUniqCodes);
     }

src/V3TraceDecl.cpp

@@ -241,7 +241,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstScope* nodep) override {
+    void visit(AstScope* nodep) override {
         UASSERT_OBJ(!m_currScopep, nodep, "Should not nest");
         UASSERT_OBJ(m_subFuncps.empty(), nodep, "Should not nest");
         UASSERT_OBJ(m_signals.empty(), nodep, "Should not nest");
@@ -330,7 +330,7 @@ private:
             m_scopeSubFuncps.emplace(scopeName, std::move(m_subFuncps));
         }
     }
-    virtual void visit(AstVarScope* nodep) override {
+    void visit(AstVarScope* nodep) override {
         UASSERT_OBJ(m_currScopep, nodep, "AstVarScope not under AstScope");
 
         // Prefilter - things that get added to m_vscps will either get traced or get a comment as
@@ -345,13 +345,13 @@ private:
     }
 
     // VISITORS - Data types when tracing
-    virtual void visit(AstConstDType* nodep) override {
+    void visit(AstConstDType* nodep) override {
         if (m_traVscp) iterate(nodep->subDTypep()->skipRefToEnump());
     }
-    virtual void visit(AstRefDType* nodep) override {
+    void visit(AstRefDType* nodep) override {
         if (m_traVscp) iterate(nodep->subDTypep()->skipRefToEnump());
     }
-    virtual void visit(AstUnpackArrayDType* nodep) override {
+    void visit(AstUnpackArrayDType* nodep) override {
         // Note more specific dtypes above
         if (m_traVscp) {
             if (static_cast<int>(nodep->arrayUnpackedElements()) > v3Global.opt.traceMaxArray()) {
@@ -386,7 +386,7 @@ private:
             }
         }
     }
-    virtual void visit(AstPackArrayDType* nodep) override {
+    void visit(AstPackArrayDType* nodep) override {
         if (m_traVscp) {
             if (!v3Global.opt.traceStructs()) {
                 // Everything downstream is packed, so deal with as one trace unit.
@@ -412,7 +412,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) override {
+    void visit(AstNodeUOrStructDType* nodep) override {
         if (m_traVscp) {
             if (nodep->packed() && !v3Global.opt.traceStructs()) {
                 // Everything downstream is packed, so deal with as one trace unit
@@ -449,7 +449,7 @@ private:
             }
         }
     }
-    virtual void visit(AstBasicDType* nodep) override {
+    void visit(AstBasicDType* nodep) override {
         if (m_traVscp) {
             if (nodep->isString()) {
                 addIgnore("Unsupported: strings");
@@ -458,15 +458,15 @@ private:
             }
         }
     }
-    virtual void visit(AstEnumDType* nodep) override { iterate(nodep->skipRefp()); }
-    virtual void visit(AstNodeDType*) override {
+    void visit(AstEnumDType* nodep) override { iterate(nodep->skipRefp()); }
+    void visit(AstNodeDType*) override {
         // Note more specific dtypes above
         if (!m_traVscp) return;
         addIgnore("Unsupported: data type");
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -513,7 +513,7 @@ public:
         AstCFunc* const topFuncp = m_topFuncps.front();
         topFuncp->name("trace_init_top");
     }
-    virtual ~TraceDeclVisitor() override {
+    ~TraceDeclVisitor() override {
         V3Stats::addStat("Tracing, Traced signals", m_statSigs);
         V3Stats::addStat("Tracing, Ignored signals", m_statIgnSigs);
     }

src/V3Tristate.cpp

@@ -118,17 +118,17 @@ public:
     TristateVertex(V3Graph* graphp, AstNode* nodep)
         : V3GraphVertex{graphp}
         , m_nodep{nodep} {}
-    virtual ~TristateVertex() override = default;
+    ~TristateVertex() override = default;
     // ACCESSORS
     AstNode* nodep() const { return m_nodep; }
     const AstVar* varp() const { return VN_CAST(nodep(), Var); }
-    virtual string name() const override {
+    string name() const override {
         return ((isTristate() ? "tri\\n"
                  : feedsTri() ? "feed\\n"
                               : "-\\n")
                 + (nodep()->prettyTypeName() + " " + cvtToHex(nodep())));
     }
-    virtual string dotColor() const override {
+    string dotColor() const override {
         return (varp() ? (isTristate() ? "darkblue"
                           : feedsTri() ? "blue"
                                        : "lightblue")
@@ -136,7 +136,7 @@ public:
                           : feedsTri() ? "green"
                                        : "lightgreen"));
     }
-    virtual FileLine* fileline() const override { return nodep()->fileline(); }
+    FileLine* fileline() const override { return nodep()->fileline(); }
     void isTristate(bool flag) { m_isTristate = flag; }
     bool isTristate() const { return m_isTristate; }
     void feedsTri(bool flag) { m_feedsTri = flag; }
@@ -312,7 +312,7 @@ class TristatePinVisitor final : public TristateBaseVisitor {
     TristateGraph& m_tgraph;
     const bool m_lvalue;  // Flip to be an LVALUE
     // VISITORS
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         UASSERT_OBJ(!nodep->access().isRW(), nodep, "Tristate unexpected on R/W access flip");
         if (m_lvalue && !nodep->access().isWriteOrRW()) {
             UINFO(9, "  Flip-to-LValue " << nodep << endl);
@@ -325,17 +325,17 @@ class TristatePinVisitor final : public TristateBaseVisitor {
             m_tgraph.setTristate(nodep->varp());
         }
     }
-    virtual void visit(AstArraySel* nodep) override {
+    void visit(AstArraySel* nodep) override {
         // Doesn't work because we'd set lvalue on the array index's var
         UASSERT_OBJ(!m_lvalue, nodep, "ArraySel conversion to output, under tristate node");
         iterateChildren(nodep);
     }
-    virtual void visit(AstSliceSel* nodep) override {
+    void visit(AstSliceSel* nodep) override {
         // Doesn't work because we'd set lvalue on the array index's var
         UASSERT_OBJ(!m_lvalue, nodep, "SliceSel conversion to output, under tristate node");
         iterateChildren(nodep);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -344,7 +344,7 @@ public:
         , m_lvalue{lvalue} {
         iterate(nodep);
     }
-    virtual ~TristatePinVisitor() override = default;
+    ~TristatePinVisitor() override = default;
 };
 
 //######################################################################
@@ -778,7 +778,7 @@ class TristateVisitor final : public TristateBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         UINFO(9, dbgState() << nodep << endl);
         if (m_graphing) {
             if (!m_alhs && nodep->num().hasZ()) m_tgraph.setTristate(nodep);
@@ -811,7 +811,7 @@ class TristateVisitor final : public TristateBaseVisitor {
         }
     }
 
-    virtual void visit(AstCond* nodep) override {
+    void visit(AstCond* nodep) override {
         if (m_graphing) {
             iterateChildren(nodep);
             if (m_alhs) {
@@ -856,7 +856,7 @@ class TristateVisitor final : public TristateBaseVisitor {
         }
     }
 
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         if (m_graphing) {
             iterateChildren(nodep);
             if (m_alhs) {
@@ -895,7 +895,7 @@ class TristateVisitor final : public TristateBaseVisitor {
         }
     }
 
-    virtual void visit(AstConcat* nodep) override {
+    void visit(AstConcat* nodep) override {
         if (m_graphing) {
             iterateChildren(nodep);
             if (m_alhs) {
@@ -941,7 +941,7 @@ class TristateVisitor final : public TristateBaseVisitor {
         }
     }
 
-    virtual void visit(AstBufIf1* nodep) override {
+    void visit(AstBufIf1* nodep) override {
         // For BufIf1, the enable is the LHS expression
         iterateChildren(nodep);
         UINFO(9, dbgState() << nodep << endl);
@@ -1025,8 +1025,8 @@ class TristateVisitor final : public TristateBaseVisitor {
             expr2p->user1p(nullptr);
         }
     }
-    virtual void visit(AstAnd* nodep) override { visitAndOr(nodep, true); }
-    virtual void visit(AstOr* nodep) override { visitAndOr(nodep, false); }
+    void visit(AstAnd* nodep) override { visitAndOr(nodep, true); }
+    void visit(AstOr* nodep) override { visitAndOr(nodep, false); }
 
     void visitAssign(AstNodeAssign* nodep) {
         if (m_graphing) {
@@ -1065,8 +1065,8 @@ class TristateVisitor final : public TristateBaseVisitor {
             m_alhs = false;
         }
     }
-    virtual void visit(AstAssignW* nodep) override { visitAssign(nodep); }
-    virtual void visit(AstAssign* nodep) override { visitAssign(nodep); }
+    void visit(AstAssignW* nodep) override { visitAssign(nodep); }
+    void visit(AstAssign* nodep) override { visitAssign(nodep); }
 
     void visitCaseEq(AstNodeBiop* nodep, bool neq) {
         if (m_graphing) {
@@ -1136,12 +1136,12 @@ class TristateVisitor final : public TristateBaseVisitor {
             return;
         }
     }
-    virtual void visit(AstEqCase* nodep) override { visitCaseEq(nodep, false); }
-    virtual void visit(AstNeqCase* nodep) override { visitCaseEq(nodep, true); }
-    virtual void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
-    virtual void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
+    void visit(AstEqCase* nodep) override { visitCaseEq(nodep, false); }
+    void visit(AstNeqCase* nodep) override { visitCaseEq(nodep, true); }
+    void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
+    void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
 
-    virtual void visit(AstCountBits* nodep) override {
+    void visit(AstCountBits* nodep) override {
         std::array<bool, 3> dropop;
         dropop[0] = VN_IS(nodep->rhsp(), Const) && VN_AS(nodep->rhsp(), Const)->num().isAnyZ();
         dropop[1] = VN_IS(nodep->thsp(), Const) && VN_AS(nodep->thsp(), Const)->num().isAnyZ();
@@ -1201,7 +1201,7 @@ class TristateVisitor final : public TristateBaseVisitor {
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstPull* nodep) override {
+    void visit(AstPull* nodep) override {
         UINFO(9, dbgState() << nodep << endl);
         AstVarRef* varrefp = nullptr;
         if (VN_IS(nodep->lhsp(), VarRef)) {
@@ -1276,7 +1276,7 @@ class TristateVisitor final : public TristateBaseVisitor {
     //                     __out(to-resolver-only)
     //     const inout  Spec says illegal
     //     const output Unsupported; Illegal?
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         if (m_graphing) {
             if (nodep->user2() & U2_GRAPHING) return;  // This pin is already expanded
             nodep->user2(U2_GRAPHING);
@@ -1445,7 +1445,7 @@ class TristateVisitor final : public TristateBaseVisitor {
         }
     }
 
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         UINFO(9, dbgState() << nodep << endl);
         if (m_graphing) {
             if (nodep->access().isWriteOrRW()) associateLogic(nodep, nodep->varp());
@@ -1477,7 +1477,7 @@ class TristateVisitor final : public TristateBaseVisitor {
         }
     }
 
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         iterateChildren(nodep);
         UINFO(9, dbgState() << nodep << endl);
         if (m_graphing) {
@@ -1510,7 +1510,7 @@ class TristateVisitor final : public TristateBaseVisitor {
         }
     }
 
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         UINFO(8, nodep << endl);
         VL_RESTORER(m_modp);
         VL_RESTORER(m_graphing);
@@ -1546,29 +1546,29 @@ class TristateVisitor final : public TristateBaseVisitor {
         m_tgraph.clear();  // Recursion not supported
     }
 
-    virtual void visit(AstClass* nodep) override {
+    void visit(AstClass* nodep) override {
         // don't deal with classes
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         // don't deal with functions
     }
 
-    virtual void visit(AstCaseItem* nodep) override {
+    void visit(AstCaseItem* nodep) override {
         // don't deal with casez compare '???? values
         iterateAndNextNull(nodep->bodysp());
     }
 
-    virtual void visit(AstCell* nodep) override {
+    void visit(AstCell* nodep) override {
         VL_RESTORER(m_cellp);
         m_cellp = nodep;
         m_alhs = false;
         iterateChildren(nodep);
     }
 
-    virtual void visit(AstNetlist* nodep) override { iterateChildrenBackwards(nodep); }
+    void visit(AstNetlist* nodep) override { iterateChildrenBackwards(nodep); }
 
     // Default: Just iterate
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         checkUnhandled(nodep);
     }
@@ -1579,7 +1579,7 @@ public:
         m_tgraph.clear();
         iterate(nodep);
     }
-    virtual ~TristateVisitor() override {
+    ~TristateVisitor() override {
         V3Stats::addStat("Tristate, Tristate resolved nets", m_statTriSigs);
     }
 };

src/V3Undriven.cpp

@@ -294,7 +294,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstVar* nodep) override {
+    void visit(AstVar* nodep) override {
         for (int usr = 1; usr < (m_alwaysCombp ? 3 : 2); ++usr) {
             // For assigns and non-combo always, do just usr==1, to look
             // for module-wide undriven etc.
@@ -315,15 +315,15 @@ private:
         // Discover variables used in bit definitions, etc
         iterateChildren(nodep);
     }
-    virtual void visit(AstArraySel* nodep) override {
+    void visit(AstArraySel* nodep) override {
         // Arrays are rarely constant assigned, so for now we punt and do all entries
         iterateChildren(nodep);
     }
-    virtual void visit(AstSliceSel* nodep) override {
+    void visit(AstSliceSel* nodep) override {
         // Arrays are rarely constant assigned, so for now we punt and do all entries
         iterateChildren(nodep);
     }
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         AstNodeVarRef* const varrefp = VN_CAST(nodep->fromp(), NodeVarRef);
         AstConst* const constp = VN_CAST(nodep->lsbp(), Const);
         if (varrefp && constp && !constp->num().isFourState()) {
@@ -347,7 +347,7 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         // Any variable
         if (nodep->access().isWriteOrRW()
             && !VN_IS(nodep, VarXRef)) {  // Ignore interface variables and similar ugly items
@@ -388,7 +388,7 @@ private:
     }
 
     // Don't know what black boxed calls do, assume in+out
-    virtual void visit(AstSysIgnore* nodep) override {
+    void visit(AstSysIgnore* nodep) override {
         VL_RESTORER(m_inBBox);
         {
             m_inBBox = true;
@@ -396,28 +396,28 @@ private:
         }
     }
 
-    virtual void visit(AstAssign* nodep) override {
+    void visit(AstAssign* nodep) override {
         VL_RESTORER(m_inProcAssign);
         {
             m_inProcAssign = true;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         VL_RESTORER(m_inProcAssign);
         {
             m_inProcAssign = true;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         VL_RESTORER(m_inContAssign);
         {
             m_inContAssign = true;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstAlways* nodep) override {
+    void visit(AstAlways* nodep) override {
         VL_RESTORER(m_alwaysCombp);
         {
             AstNode::user2ClearTree();
@@ -432,37 +432,37 @@ private:
         }
     }
 
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         VL_RESTORER(m_taskp);
         {
             m_taskp = nodep;
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstPin* nodep) override {
+    void visit(AstPin* nodep) override {
         VL_RESTORER(m_inInoutPin);
         m_inInoutPin = nodep->modVarp()->isInoutish();
         iterateChildren(nodep);
     }
 
     // Until we support tables, primitives will have undriven and unused I/Os
-    virtual void visit(AstPrimitive*) override {}
+    void visit(AstPrimitive*) override {}
 
     // Coverage artifacts etc shouldn't count as a sink
-    virtual void visit(AstCoverDecl*) override {}
-    virtual void visit(AstCoverInc*) override {}
-    virtual void visit(AstCoverToggle*) override {}
-    virtual void visit(AstTraceDecl*) override {}
-    virtual void visit(AstTraceInc*) override {}
+    void visit(AstCoverDecl*) override {}
+    void visit(AstCoverInc*) override {}
+    void visit(AstCoverToggle*) override {}
+    void visit(AstTraceDecl*) override {}
+    void visit(AstTraceInc*) override {}
 
     // iterate
-    virtual void visit(AstConst* nodep) override {}
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstConst* nodep) override {}
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     explicit UndrivenVisitor(AstNetlist* nodep) { iterate(nodep); }
-    virtual ~UndrivenVisitor() override {
+    ~UndrivenVisitor() override {
         for (UndrivenVarEntry* ip : m_entryps[1]) ip->reportViolations();
         for (int usr = 1; usr < 3; ++usr) {
             for (UndrivenVarEntry* ip : m_entryps[usr]) delete ip;

src/V3Unknown.cpp

@@ -138,7 +138,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         UINFO(4, " MOD   " << nodep << endl);
         VL_RESTORER(m_modp);
         VL_RESTORER(m_constXCvt);
@@ -153,21 +153,21 @@ private:
             iterateChildren(nodep);
         }
     }
-    virtual void visit(AstAssignDly* nodep) override {
+    void visit(AstAssignDly* nodep) override {
         VL_RESTORER(m_assigndlyp);
         {
             m_assigndlyp = nodep;
             VL_DO_DANGLING(iterateChildren(nodep), nodep);  // May delete nodep.
         }
     }
-    virtual void visit(AstAssignW* nodep) override {
+    void visit(AstAssignW* nodep) override {
         VL_RESTORER(m_assignwp);
         {
             m_assignwp = nodep;
             VL_DO_DANGLING(iterateChildren(nodep), nodep);  // May delete nodep.
         }
     }
-    virtual void visit(AstCaseItem* nodep) override {
+    void visit(AstCaseItem* nodep) override {
         VL_RESTORER(m_constXCvt);
         {
             m_constXCvt = false;  // Avoid losing the X's in casex
@@ -176,7 +176,7 @@ private:
             iterateAndNextNull(nodep->bodysp());
         }
     }
-    virtual void visit(AstNodeDType* nodep) override {
+    void visit(AstNodeDType* nodep) override {
         VL_RESTORER(m_constXCvt);
         {
             m_constXCvt = false;  // Avoid losing the X's in casex
@@ -255,11 +255,11 @@ private:
         }
     }
 
-    virtual void visit(AstEqCase* nodep) override { visitEqNeqCase(nodep); }
-    virtual void visit(AstNeqCase* nodep) override { visitEqNeqCase(nodep); }
-    virtual void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
-    virtual void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
-    virtual void visit(AstIsUnknown* nodep) override {
+    void visit(AstEqCase* nodep) override { visitEqNeqCase(nodep); }
+    void visit(AstNeqCase* nodep) override { visitEqNeqCase(nodep); }
+    void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
+    void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
+    void visit(AstIsUnknown* nodep) override {
         iterateChildren(nodep);
         // Ahh, we're two state, so this is easy
         UINFO(4, " ISUNKNOWN->0 " << nodep << endl);
@@ -267,7 +267,7 @@ private:
         nodep->replaceWith(newp);
         VL_DO_DANGLING(nodep->deleteTree(), nodep);
     }
-    virtual void visit(AstCountBits* nodep) override {
+    void visit(AstCountBits* nodep) override {
         // Ahh, we're two state, so this is easy
         std::array<bool, 3> dropop;
         dropop[0] = VN_IS(nodep->rhsp(), Const) && VN_AS(nodep->rhsp(), Const)->num().isAnyX();
@@ -303,7 +303,7 @@ private:
         }
         iterateChildren(nodep);
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         if (m_constXCvt && nodep->num().isFourState()) {
             UINFO(4, " CONST4 " << nodep << endl);
             if (debug() >= 9) nodep->dumpTree(cout, "  Const_old: ");
@@ -364,7 +364,7 @@ private:
         }
     }
 
-    virtual void visit(AstSel* nodep) override {
+    void visit(AstSel* nodep) override {
         iterateChildren(nodep);
         if (!nodep->user1SetOnce()) {
             // Guard against reading/writing past end of bit vector array
@@ -411,7 +411,7 @@ private:
     // visit(AstSliceSel) not needed as its bounds are constant and checked
     // in V3Width.
 
-    virtual void visit(AstArraySel* nodep) override {
+    void visit(AstArraySel* nodep) override {
         iterateChildren(nodep);
         if (!nodep->user1SetOnce()) {
             if (debug() == 9) nodep->dumpTree(cout, "-in: ");
@@ -482,7 +482,7 @@ private:
         }
     }
     //--------------------
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
@@ -491,7 +491,7 @@ public:
         , m_xrandNames{"__Vxrand"} {
         iterate(nodep);
     }
-    virtual ~UnknownVisitor() override {  //
+    ~UnknownVisitor() override {  //
         V3Stats::addStat("Unknowns, variables created", m_statUnkVars);
     }
 };

src/V3Unroll.cpp

@@ -371,7 +371,7 @@ private:
         return true;
     }
 
-    virtual void visit(AstWhile* nodep) override {
+    void visit(AstWhile* nodep) override {
         iterateChildren(nodep);
         if (m_varModeCheck || m_varModeReplace) {
         } else {
@@ -406,7 +406,7 @@ private:
             }
         }
     }
-    virtual void visit(AstGenFor* nodep) override {
+    void visit(AstGenFor* nodep) override {
         if (!m_generate || m_varModeReplace) {
             iterateChildren(nodep);
         }  // else V3Param will recursively call each for loop to be unrolled for us
@@ -433,7 +433,7 @@ private:
             }
         }
     }
-    virtual void visit(AstNodeFor* nodep) override {
+    void visit(AstNodeFor* nodep) override {
         if (m_generate) {  // Ignore for's when expanding genfor's
             iterateChildren(nodep);
         } else {
@@ -441,7 +441,7 @@ private:
         }
     }
 
-    virtual void visit(AstVarRef* nodep) override {
+    void visit(AstVarRef* nodep) override {
         if (m_varModeCheck && nodep->varp() == m_forVarp && nodep->varScopep() == m_forVscp
             && nodep->access().isWriteOrRW()) {
             UINFO(8, "   Itervar assigned to: " << nodep << endl);
@@ -458,7 +458,7 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         if (m_varModeCheck && nodep == m_ignoreIncp) {
             // Ignore subtree that is the increment
         } else {
@@ -469,7 +469,7 @@ private:
 public:
     // CONSTRUCTORS
     UnrollVisitor() { init(false, ""); }
-    virtual ~UnrollVisitor() override {
+    ~UnrollVisitor() override {
         V3Stats::addStatSum("Optimizations, Unrolled Loops", m_statLoops);
         V3Stats::addStatSum("Optimizations, Unrolled Iterations", m_statIters);
     }

src/V3VariableOrder.cpp

@@ -51,12 +51,12 @@ public:
     }
     ~VarTspSorter() override = default;
     // METHODS
-    virtual bool operator<(const TspStateBase& other) const override {
+    bool operator<(const TspStateBase& other) const override {
         return operator<(static_cast<const VarTspSorter&>(other));
     }
     bool operator<(const VarTspSorter& other) const { return m_serial < other.m_serial; }
     const MTaskIdSet& mtaskIds() const { return m_mtaskIds; }
-    virtual int cost(const TspStateBase* otherp) const override {
+    int cost(const TspStateBase* otherp) const override {
         return cost(static_cast<const VarTspSorter*>(otherp));
     }
     int cost(const VarTspSorter* otherp) const {

src/V3WidthCommit.h

@@ -45,18 +45,18 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstSigned* nodep) override {
+    void visit(AstSigned* nodep) override {
         VL_DO_DANGLING(replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()), nodep);
     }
-    virtual void visit(AstUnsigned* nodep) override {
+    void visit(AstUnsigned* nodep) override {
         VL_DO_DANGLING(replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()), nodep);
     }
-    virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
+    void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
 public:
     // CONSTRUCTORS
     WidthRemoveVisitor() = default;
-    virtual ~WidthRemoveVisitor() override = default;
+    ~WidthRemoveVisitor() override = default;
     AstNode* mainAcceptEdit(AstNode* nodep) { return iterateSubtreeReturnEdits(nodep); }
 };
 
@@ -151,7 +151,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep) override {
+    void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         {
             m_modp = nodep;
@@ -159,7 +159,7 @@ private:
             editDType(nodep);
         }
     }
-    virtual void visit(AstConst* nodep) override {
+    void visit(AstConst* nodep) override {
         UASSERT_OBJ(nodep->dtypep(), nodep, "No dtype");
         iterate(nodep->dtypep());  // Do datatype first
         if (AstConst* const newp = newIfConstCommitSize(nodep)) {
@@ -172,15 +172,15 @@ private:
         }
         editDType(nodep);
     }
-    virtual void visit(AstNodeDType* nodep) override {  //
+    void visit(AstNodeDType* nodep) override {  //
         visitIterateNodeDType(nodep);
     }
-    virtual void visit(AstNodeUOrStructDType* nodep) override {
+    void visit(AstNodeUOrStructDType* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         visitIterateNodeDType(nodep);
         nodep->clearCache();
     }
-    virtual void visit(AstParamTypeDType* nodep) override {
+    void visit(AstParamTypeDType* nodep) override {
         if (nodep->user1SetOnce()) return;  // Process once
         visitIterateNodeDType(nodep);
         // Move to type table as all dtype pointers must resolve there
@@ -199,7 +199,7 @@ private:
         nodep->virtRefDTypep(editOneDType(nodep->virtRefDTypep()));
         nodep->virtRefDType2p(editOneDType(nodep->virtRefDType2p()));
     }
-    virtual void visit(AstNodeFTask* nodep) override {
+    void visit(AstNodeFTask* nodep) override {
         iterateChildren(nodep);
         editDType(nodep);
         if (nodep->classMethod() && nodep->pureVirtual() && VN_IS(m_modp, Class)
@@ -208,28 +208,28 @@ private:
                 "Illegal to have 'pure virtual' in non-virtual class (IEEE 1800-2017 8.21)");
         }
     }
-    virtual void visit(AstNodeVarRef* nodep) override {
+    void visit(AstNodeVarRef* nodep) override {
         iterateChildren(nodep);
         editDType(nodep);
         classEncapCheck(nodep, nodep->varp(), VN_CAST(nodep->classOrPackagep(), Class));
     }
-    virtual void visit(AstNodeFTaskRef* nodep) override {
+    void visit(AstNodeFTaskRef* nodep) override {
         iterateChildren(nodep);
         editDType(nodep);
         classEncapCheck(nodep, nodep->taskp(), VN_CAST(nodep->classOrPackagep(), Class));
     }
-    virtual void visit(AstMemberSel* nodep) override {
+    void visit(AstMemberSel* nodep) override {
         iterateChildren(nodep);
         editDType(nodep);
         if (auto* const classrefp = VN_CAST(nodep->fromp()->dtypep(), ClassRefDType)) {
             classEncapCheck(nodep, nodep->varp(), classrefp->classp());
         }  // else might be struct, etc
     }
-    virtual void visit(AstNodePreSel* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstNodePreSel* nodep) override {  // LCOV_EXCL_LINE
         // This check could go anywhere after V3Param
         nodep->v3fatalSrc("Presels should have been removed before this point");
     }
-    virtual void visit(AstNode* nodep) override {
+    void visit(AstNode* nodep) override {
         iterateChildren(nodep);
         editDType(nodep);
     }
@@ -243,7 +243,7 @@ public:
         // Don't want to repairCache, as all needed nodes have been added back in
         // a repair would prevent dead nodes from being detected
     }
-    virtual ~WidthCommitVisitor() override = default;
+    ~WidthCommitVisitor() override = default;
 };
 
 //######################################################################

src/V3WidthSel.cpp

@@ -202,7 +202,7 @@ private:
     // VISITORS
     // If adding new visitors, ensure V3Width's visit(TYPE) calls into here
 
-    virtual void visit(AstSelBit* nodep) override {
+    void visit(AstSelBit* nodep) override {
         // 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);
@@ -330,7 +330,7 @@ private:
         }
         if (!rhsp->backp()) VL_DO_DANGLING(pushDeletep(rhsp), rhsp);
     }
-    virtual void visit(AstSelExtract* nodep) override {
+    void visit(AstSelExtract* nodep) override {
         // 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
@@ -584,13 +584,13 @@ private:
         if (!rhsp->backp()) VL_DO_DANGLING(pushDeletep(rhsp), rhsp);
         if (!widthp->backp()) VL_DO_DANGLING(pushDeletep(widthp), widthp);
     }
-    virtual void visit(AstSelPlus* nodep) override { replaceSelPlusMinus(nodep); }
-    virtual void visit(AstSelMinus* nodep) override { replaceSelPlusMinus(nodep); }
+    void visit(AstSelPlus* nodep) override { replaceSelPlusMinus(nodep); }
+    void visit(AstSelMinus* nodep) override { replaceSelPlusMinus(nodep); }
     // If adding new visitors, ensure V3Width's visit(TYPE) calls into here
 
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep) override {  // LCOV_EXCL_LINE
+    void visit(AstNode* nodep) override {  // LCOV_EXCL_LINE
         // See notes above; we never iterate
         nodep->v3fatalSrc("Shouldn't iterate in V3WidthSel");
     }
@@ -598,7 +598,7 @@ private:
 public:
     // CONSTRUCTORS
     WidthSelVisitor() = default;
-    virtual ~WidthSelVisitor() override = default;
+    ~WidthSelVisitor() override = default;
     AstNode* mainAcceptEdit(AstNode* nodep) { return iterateSubtreeReturnEdits(nodep); }
 };
 

src/astgen

@@ -468,7 +468,7 @@ class Cpt:
             if len(out_for_type_sc) > 0:  # Short-circuited types
                 self.print(
                     "    // Generated by astgen with short-circuiting\n" +
-                    "    virtual void visit(Ast" + node.name +
+                    "    void visit(Ast" + node.name +
                     "* nodep) override {\n" +
                     "      iterateAndNextNull(nodep->lhsp());\n" +
                     "".join(out_for_type_sc))
@@ -481,10 +481,12 @@ class Cpt:
             elif len(out_for_type) > 0:  # Other types with something to print
                 skip = node.name in self.tree_skip_visit
                 gen = "Gen" if skip else ""
+                virtual = "virtual " if skip else ""
                 override = "" if skip else " override"
                 self.print(
-                    "    // Generated by astgen\n" + "    virtual void visit" +
-                    gen + "(Ast" + node.name + "* nodep)" + override + " {\n" +
+                    "    // Generated by astgen\n" + "    " + virtual +
+                    "void visit" + gen + "(Ast" + node.name + "* nodep)" +
+                    override + " {\n" +
                     ("" if skip else "        iterateChildren(nodep);\n") +
                     ''.join(out_for_type) + "    }\n")
 
@@ -751,8 +753,8 @@ def write_macros(filename):
 
             if node.isLeaf:
                 emitBlock('''\
-                virtual void accept(VNVisitor& v) override {{ v.visit(this); }}
-                virtual AstNode* clone() override {{ return new Ast{t}(*this); }}
+                void accept(VNVisitor& v) override {{ v.visit(this); }}
+                AstNode* clone() override {{ return new Ast{t}(*this); }}
                 ''',
                           t=node.name)
 

test_regress/t/t_dist_cppstyle.pl

@@ -0,0 +1,66 @@
+#!/usr/bin/env perl
+if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
+# DESCRIPTION: Verilator: Primitive C++ style checker
+#
+# Copyright 2022 by Geza Lore. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+scenarios(dist => 1);
+
+my $root = "..";
+
+### Must trim output before and after our file list
+my %files = %{get_source_files($root)};
+
+foreach my $file (sort keys %files) {
+    my $filename = "$root/$file";
+    next if !-f $filename;  # git file might be deleted but not yet staged
+    next unless $file =~ /\.(h|c|cpp)(\.in)?$/;
+    next if $file =~ /gtkwave/;
+
+    my $contents = file_contents($filename);
+
+    checkPattern($filename, $contents,
+                 qr/virtual[^{};]+override/,
+                 "'virtual' keyword is redundant on 'override' method");
+}
+
+ok(1);
+1;
+
+sub get_source_files {
+    my $root = shift;
+    my $git_files = `cd $root && git ls-files`;
+    print "MF $git_files\n" if $Self->{verbose};
+    my %files;
+    foreach my $file (split /\s+/, $git_files) {
+        next if $file eq '';
+        $files{$file} |= 1;
+    }
+    return \%files;
+}
+
+sub checkPattern {
+    my $filename = shift;
+    my $contents = shift;
+    my $pattern = shift;
+    my $message = shift;
+
+    my $offset = 0;
+    my $buffer = $contents;
+    while ($buffer =~ s/.*?^[^\/]*($pattern)//sm) {
+      my $lineno = offset_to_lineno($contents, $offset + $-[1]);
+      $offset += $+[1];
+      error("$filename:$lineno: $message");
+    }
+}
+
+sub offset_to_lineno {
+    my $contents = shift;
+    my $offset = shift;
+    my $count = (substr $contents, 0, $offset) =~ tr/\n//;
+    return $count + 1;
+}