Merge branch 'master' into develop-v5

.clang-format

@@ -17,7 +17,7 @@ AllowShortLoopsOnASingleLine: true
 AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: false
+AlwaysBreakTemplateDeclarations: true
 BinPackArguments: true
 BinPackParameters: true
 BraceWrapping:
@@ -59,15 +59,27 @@ ForEachMacros:
   - foreach
   - Q_FOREACH
   - BOOST_FOREACH
-IncludeBlocks:   Preserve
+
+# Include grouping/sorting
+SortIncludes:    true
+IncludeBlocks:   Regroup
 IncludeCategories:
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-    Priority:        2
-  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
-    Priority:        3
-  - Regex:           '.*'
-    Priority:        1
-IncludeIsMainRegex: '(Test)?$'
+  - Regex:           '"(config_build|verilated_config|verilatedos)\.h"'
+    Priority:        -1 # Sepecials before main header
+  - Regex:           '(<|")verilated.*'
+    Priority:        1 # Runtime headers
+  - Regex:           '"V3.*__gen.*\.h"'
+    Priority:        3 # Generated internal headers separately
+  - Regex:           '"V3.*"'
+    Priority:        2 # Internal header
+  - Regex:           '".*"'
+    Priority:        4 # Other non-system headers
+  - Regex:           '<[[:alnum:]_.]+>'
+    Priority:        5 # Simple system headers next
+  - Regex:           '<.*>'
+    Priority:        6 # Other system headers next
+IncludeIsMainRegex: '$'
+
 IndentCaseLabels: false
 IndentPPDirectives: None
 IndentWidth:     4
@@ -91,7 +103,6 @@ PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Left
 ReflowComments:  true
-SortIncludes:    false
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
 SpaceAfterTemplateKeyword: true

include/verilated.cpp

@@ -47,21 +47,22 @@
 
 #define VERILATOR_VERILATED_CPP_
 
-#include "verilatedos.h"
-#include "verilated_imp.h"
-
 #include "verilated_config.h"
+#include "verilatedos.h"
+
+#include "verilated_imp.h"
 
 #include <algorithm>
 #include <cctype>
 #include <cerrno>
 #include <cstdlib>
-#include <sstream>
-#include <sys/stat.h>  // mkdir
-#include <list>
 #include <limits>
+#include <list>
+#include <sstream>
 #include <utility>
 
+#include <sys/stat.h>  // mkdir
+
 // clang-format off
 #if defined(_WIN32) || defined(__MINGW32__)
 # include <direct.h>  // mkdir

include/verilated.h

@@ -91,7 +91,8 @@ class VerilatedFstC;
 class VerilatedFstSc;
 class VerilatedScope;
 class VerilatedScopeNameMap;
-template <class, class> class VerilatedTrace;
+template <class, class>
+class VerilatedTrace;
 class VerilatedTraceConfig;
 class VerilatedVar;
 class VerilatedVarNameMap;
@@ -283,7 +284,8 @@ public:
 
 private:
     // The following are for use by Verilator internals only
-    template <class, class> friend class VerilatedTrace;
+    template <class, class>
+    friend class VerilatedTrace;
     // Run-time trace configuration requested by this model
     virtual std::unique_ptr<VerilatedTraceConfig> traceConfig() const;
 };

include/verilated_cov.cpp

@@ -22,8 +22,10 @@
 //=============================================================================
 
 #include "verilatedos.h"
-#include "verilated.h"
+
 #include "verilated_cov.h"
+
+#include "verilated.h"
 #include "verilated_cov_key.h"
 
 #include <deque>
@@ -69,7 +71,8 @@ public:  // But only local to this file
 // This isn't in the header file for auto-magic conversion because it
 // inlines to too much code and makes compilation too slow.
 
-template <class T> class VerilatedCoverItemSpec final : public VerilatedCovImpItem {
+template <class T>
+class VerilatedCoverItemSpec final : public VerilatedCovImpItem {
 private:
     // MEMBERS
     T* m_countp;  // Count value

include/verilated_cov.h

@@ -26,6 +26,7 @@
 #define VERILATOR_VERILATED_COV_H_
 
 #include "verilatedos.h"
+
 #include "verilated.h"
 
 #include <iostream>
@@ -88,7 +89,8 @@ class VerilatedCovImp;
 //=============================================================================
 // Convert VL_COVER_INSERT value arguments to strings, is \internal
 
-template <class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
+template <class T>
+std::string vlCovCvtToStr(const T& t) VL_PURE {
     std::ostringstream os;
     os << t;
     return os.str();

include/verilated_dpi.cpp

@@ -28,7 +28,9 @@
 #define VERILATOR_VERILATED_DPI_CPP_
 
 #include "verilatedos.h"
+
 #include "verilated_dpi.h"
+
 #include "verilated_imp.h"
 
 // On MSVC++ we need svdpi.h to declare exports, not imports

include/verilated_dpi.h

@@ -27,6 +27,7 @@
 #define VERILATOR_VERILATED_DPI_H_
 
 #include "verilatedos.h"
+
 #include "verilated.h"  // Also presumably included by caller
 #include "verilated_sym_props.h"
 

include/verilated_fst_c.h

@@ -118,12 +118,18 @@ public:
 
 #ifndef DOXYGEN
 // Declare specialization here as it's used in VerilatedFstC just below
-template <> void VerilatedFst::Super::dump(uint64_t time);
-template <> void VerilatedFst::Super::set_time_unit(const char* unitp);
-template <> void VerilatedFst::Super::set_time_unit(const std::string& unit);
-template <> void VerilatedFst::Super::set_time_resolution(const char* unitp);
-template <> void VerilatedFst::Super::set_time_resolution(const std::string& unit);
-template <> void VerilatedFst::Super::dumpvars(int level, const std::string& hier);
+template <>
+void VerilatedFst::Super::dump(uint64_t time);
+template <>
+void VerilatedFst::Super::set_time_unit(const char* unitp);
+template <>
+void VerilatedFst::Super::set_time_unit(const std::string& unit);
+template <>
+void VerilatedFst::Super::set_time_resolution(const char* unitp);
+template <>
+void VerilatedFst::Super::set_time_resolution(const std::string& unit);
+template <>
+void VerilatedFst::Super::dumpvars(int level, const std::string& hier);
 #endif
 
 //=============================================================================

include/verilated_fst_sc.cpp

@@ -22,6 +22,7 @@
 //=============================================================================
 
 #include "verilatedos.h"
+
 #include "verilated_fst_sc.h"
 
 //======================================================================

include/verilated_fst_sc.h

@@ -23,8 +23,9 @@
 #define _VERILATED_FST_SC_H_ 1
 
 #include "verilatedos.h"
-#include "verilated_sc.h"
+
 #include "verilated_fst_c.h"
+#include "verilated_sc.h"
 
 #include <string>
 

include/verilated_profiler.cpp

@@ -17,6 +17,7 @@
 //=============================================================================
 
 #include "verilatedos.h"
+
 #include "verilated_profiler.h"
 
 #if VL_THREADED
@@ -60,7 +61,8 @@ uint16_t VlExecutionRecord::getcpu() {
 //=============================================================================
 // VlExecutionProfiler implementation
 
-template <size_t N> static size_t roundUptoMultipleOf(size_t value) {
+template <size_t N>
+static size_t roundUptoMultipleOf(size_t value) {
     static_assert((N & (N - 1)) == 0, "'N' must be a power of 2");
     size_t mask = N - 1;
     return (value + mask) & ~mask;

include/verilated_profiler.h

@@ -23,6 +23,7 @@
 #define VERILATOR_VERILATED_PROFILER_H_
 
 #include "verilatedos.h"
+
 #include "verilated.h"
 
 #include <array>
@@ -192,7 +193,8 @@ public:
 //=============================================================================
 // VlPgoProfiler is for collecting profiling data for PGO
 
-template <std::size_t T_Entries> class VlPgoProfiler final {
+template <std::size_t T_Entries>
+class VlPgoProfiler final {
     // TYPES
     struct Record final {
         const std::string m_name;  // Hashed name of mtask/etc

include/verilated_save.cpp

@@ -24,8 +24,10 @@
 #define VERILATOR_VERILATED_SAVE_CPP_
 
 #include "verilatedos.h"
-#include "verilated.h"
+
 #include "verilated_save.h"
+
+#include "verilated.h"
 #include "verilated_imp.h"
 
 #include <cerrno>

include/verilated_save.h

@@ -23,6 +23,7 @@
 #define VERILATOR_VERILATED_SAVE_C_H_
 
 #include "verilatedos.h"
+
 #include "verilated.h"
 
 #include <string>

include/verilated_syms.h

@@ -30,6 +30,7 @@
 #define VERILATOR_VERILATED_SYMS_H_
 
 #include "verilatedos.h"
+
 #include "verilated.h"
 #include "verilated_sym_props.h"
 

include/verilated_threads.cpp

@@ -22,6 +22,7 @@
 //=============================================================================
 
 #include "verilatedos.h"
+
 #include "verilated_threads.h"
 
 #include <cstdio>

include/verilated_threads.h

@@ -24,6 +24,7 @@
 #define VERILATOR_VERILATED_THREADS_H_
 
 #include "verilatedos.h"
+
 #include "verilated.h"  // for VerilatedMutex and clang annotations
 
 #ifndef VL_THREADED
@@ -169,7 +170,7 @@ public:
     ~VlWorkerThread();
 
     // METHODS
-    template <bool SpinWait>  //
+    template <bool SpinWait>
     inline void dequeWork(ExecRec* workp) VL_MT_SAFE_EXCLUDES(m_mutex) {
         // Spin for a while, waiting for new data
         if VL_CONSTEXPR_CXX17 (SpinWait) {

include/verilated_trace.h

@@ -43,15 +43,18 @@
 // clang-format on
 
 class VlThreadPool;
-template <class T_Buffer> class VerilatedTraceBuffer;
-template <class T_Buffer> class VerilatedTraceOffloadBuffer;
+template <class T_Buffer>
+class VerilatedTraceBuffer;
+template <class T_Buffer>
+class VerilatedTraceOffloadBuffer;
 
 #ifdef VL_THREADED
 //=============================================================================
 // Offloaded tracing
 
 // A simple synchronized first in first out queue
-template <class T> class VerilatedThreadQueue final {  // LCOV_EXCL_LINE  // lcov bug
+template <class T>
+class VerilatedThreadQueue final {  // LCOV_EXCL_LINE  // lcov bug
 private:
     mutable VerilatedMutex m_mutex;  // Protects m_queue
     std::condition_variable_any m_cv;
@@ -137,7 +140,8 @@ public:
 
 // T_Trace is the format specific subclass of VerilatedTrace.
 // T_Buffer is the format specific base class of VerilatedTraceBuffer.
-template <class T_Trace, class T_Buffer> class VerilatedTrace VL_NOT_FINAL {
+template <class T_Trace, class T_Buffer>
+class VerilatedTrace VL_NOT_FINAL {
 public:
     using Buffer = VerilatedTraceBuffer<T_Buffer>;
     using OffloadBuffer = VerilatedTraceOffloadBuffer<T_Buffer>;
@@ -384,7 +388,7 @@ public:
 
 // T_Buffer is the format specific base class of VerilatedTraceBuffer.
 // The format-specific hot-path methods use duck-typing via T_Buffer for performance.
-template <class T_Buffer>  //
+template <class T_Buffer>
 class VerilatedTraceBuffer VL_NOT_FINAL : public T_Buffer {
 protected:
     // Type of the owner trace file
@@ -477,7 +481,7 @@ public:
 
 // T_Buffer is the format specific base class of VerilatedTraceBuffer.
 // The format-specific hot-path methods use duck-typing via T_Buffer for performance.
-template <class T_Buffer>  //
+template <class T_Buffer>
 class VerilatedTraceOffloadBuffer final : public VerilatedTraceBuffer<T_Buffer> {
     using typename VerilatedTraceBuffer<T_Buffer>::Trace;
 

include/verilated_trace_imp.h

@@ -82,7 +82,8 @@ static std::string doubleToTimescale(double value) {
 //=========================================================================
 // Buffer management
 
-template <> uint32_t* VerilatedTrace<VL_SUB_T, VL_BUF_T>::getOffloadBuffer() {
+template <>
+uint32_t* VerilatedTrace<VL_SUB_T, VL_BUF_T>::getOffloadBuffer() {
     uint32_t* bufferp;
     // Some jitter is expected, so some number of alternative offlaod buffers are
     // required, but don't allocate more than 8 buffers.
@@ -101,7 +102,8 @@ template <> uint32_t* VerilatedTrace<VL_SUB_T, VL_BUF_T>::getOffloadBuffer() {
     return bufferp;
 }
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::waitForOffloadBuffer(const uint32_t* buffp) {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::waitForOffloadBuffer(const uint32_t* buffp) {
     // Slow path code only called on flush/shutdown, so use a simple algorithm.
     // Collect buffers from worker and stash them until we get the one we want.
     std::deque<uint32_t*> stash;
@@ -116,7 +118,8 @@ template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::waitForOffloadBuffer(const
 //=========================================================================
 // Worker thread
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::offloadWorkerThreadMain() {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::offloadWorkerThreadMain() {
     bool shutdown = false;
 
     do {
@@ -231,7 +234,8 @@ template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::offloadWorkerThreadMain() {
     } while (VL_LIKELY(!shutdown));
 }
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::shutdownOffloadWorker() {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::shutdownOffloadWorker() {
     // If the worker thread is not running, done..
     if (!m_workerThread) return;
 
@@ -251,7 +255,8 @@ template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::shutdownOffloadWorker() {
 //=============================================================================
 // Life cycle
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::closeBase() {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::closeBase() {
 #ifdef VL_THREADED
     if (offload()) {
         shutdownOffloadWorker();
@@ -263,7 +268,8 @@ template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::closeBase() {
 #endif
 }
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::flushBase() {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::flushBase() {
 #ifdef VL_THREADED
     if (offload()) {
         // Hand an empty buffer to the worker thread
@@ -280,12 +286,14 @@ template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::flushBase() {
 //=============================================================================
 // Callbacks to run on global events
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::onFlush(void* selfp) {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::onFlush(void* selfp) {
     // This calls 'flush' on the derived class (which must then get any mutex)
     reinterpret_cast<VL_SUB_T*>(selfp)->flush();
 }
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::onExit(void* selfp) {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::onExit(void* selfp) {
     // This calls 'close' on the derived class (which must then get any mutex)
     reinterpret_cast<VL_SUB_T*>(selfp)->close();
 }
@@ -293,12 +301,14 @@ template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::onExit(void* selfp) {
 //=============================================================================
 // VerilatedTrace
 
-template <> VerilatedTrace<VL_SUB_T, VL_BUF_T>::VerilatedTrace() {
+template <>
+VerilatedTrace<VL_SUB_T, VL_BUF_T>::VerilatedTrace() {
     set_time_unit(Verilated::threadContextp()->timeunitString());
     set_time_resolution(Verilated::threadContextp()->timeprecisionString());
 }
 
-template <> VerilatedTrace<VL_SUB_T, VL_BUF_T>::~VerilatedTrace() {
+template <>
+VerilatedTrace<VL_SUB_T, VL_BUF_T>::~VerilatedTrace() {
     if (m_sigs_oldvalp) VL_DO_CLEAR(delete[] m_sigs_oldvalp, m_sigs_oldvalp = nullptr);
     if (m_sigs_enabledp) VL_DO_CLEAR(delete[] m_sigs_enabledp, m_sigs_enabledp = nullptr);
     Verilated::removeFlushCb(VerilatedTrace<VL_SUB_T, VL_BUF_T>::onFlush, this);
@@ -309,7 +319,8 @@ template <> VerilatedTrace<VL_SUB_T, VL_BUF_T>::~VerilatedTrace() {
 //=========================================================================
 // Internals available to format specific implementations
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::traceInit() VL_MT_UNSAFE {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::traceInit() VL_MT_UNSAFE {
     // Note: It is possible to re-open a trace file (VCD in particular),
     // so we must reset the next code here, but it must have the same number
     // of codes on re-open
@@ -419,14 +430,16 @@ bool VerilatedTrace<VL_SUB_T, VL_BUF_T>::declCode(uint32_t code, const char* nam
 //=========================================================================
 // Internals available to format specific implementations
 
-template <> std::string VerilatedTrace<VL_SUB_T, VL_BUF_T>::timeResStr() const {
+template <>
+std::string VerilatedTrace<VL_SUB_T, VL_BUF_T>::timeResStr() const {
     return doubleToTimescale(m_timeRes);
 }
 
 //=========================================================================
 // External interface to client code
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::set_time_unit(const char* unitp) VL_MT_SAFE {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::set_time_unit(const char* unitp) VL_MT_SAFE {
     m_timeUnit = timescaleToDouble(unitp);
 }
 template <>
@@ -456,7 +469,7 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::dumpvars(int level, const std::string&
 }
 
 #ifdef VL_THREADED
-template <>  //
+template <>
 void VerilatedTrace<VL_SUB_T, VL_BUF_T>::parallelWorkerTask(void* datap, bool) {
     ParallelWorkerData* const wdp = reinterpret_cast<ParallelWorkerData*>(datap);
     // Run the task
@@ -467,7 +480,8 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::parallelWorkerTask(void* datap, bool) {
     if (wdp->m_waiting) wdp->m_cv.notify_one();
 }
 
-template <> VL_ATTR_NOINLINE void VerilatedTrace<VL_SUB_T, VL_BUF_T>::ParallelWorkerData::wait() {
+template <>
+VL_ATTR_NOINLINE void VerilatedTrace<VL_SUB_T, VL_BUF_T>::ParallelWorkerData::wait() {
     // Spin for a while, waiting for the buffer to become ready
     for (int i = 0; i < VL_LOCK_SPINS; ++i) {
         if (VL_LIKELY(m_ready.load(std::memory_order_relaxed))) return;
@@ -723,11 +737,13 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addCleanupCb(cleanupCb_t cb, void* user
     addCallbackRecord(m_cleanupCbs, CallbackRecord{cb, userp});
 }
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::pushNamePrefix(const std::string& prefix) {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::pushNamePrefix(const std::string& prefix) {
     m_namePrefixStack.push_back(m_namePrefixStack.back() + prefix);
 }
 
-template <> void VerilatedTrace<VL_SUB_T, VL_BUF_T>::popNamePrefix(unsigned count) {
+template <>
+void VerilatedTrace<VL_SUB_T, VL_BUF_T>::popNamePrefix(unsigned count) {
     while (count--) m_namePrefixStack.pop_back();
     assert(!m_namePrefixStack.empty());
 }
@@ -825,7 +841,7 @@ static inline void cvtQDataToStr(char* dstp, QData value) {
 //=========================================================================
 // VerilatedTraceBuffer
 
-template <>  //
+template <>
 VerilatedTraceBuffer<VL_BUF_T>::VerilatedTraceBuffer(Trace& owner)
     : VL_BUF_T{owner}
     , m_sigs_oldvalp{owner.m_sigs_oldvalp}
@@ -836,7 +852,7 @@ VerilatedTraceBuffer<VL_BUF_T>::VerilatedTraceBuffer(Trace& owner)
 // that this file must be included in the format specific implementation, so
 // the emit* functions can be inlined for performance.
 
-template <>  //
+template <>
 void VerilatedTraceBuffer<VL_BUF_T>::fullBit(uint32_t* oldp, CData newval) {
     const uint32_t code = oldp - m_sigs_oldvalp;
     *oldp = newval;  // Still copy even if not tracing so chg doesn't call full
@@ -884,7 +900,7 @@ void VerilatedTraceBuffer<VL_BUF_T>::fullWData(uint32_t* oldp, const WData* newv
     emitWData(code, newvalp, bits);
 }
 
-template <>  //
+template <>
 void VerilatedTraceBuffer<VL_BUF_T>::fullDouble(uint32_t* oldp, double newval) {
     const uint32_t code = oldp - m_sigs_oldvalp;
     *reinterpret_cast<double*>(oldp) = newval;
@@ -897,7 +913,7 @@ void VerilatedTraceBuffer<VL_BUF_T>::fullDouble(uint32_t* oldp, double newval) {
 //=========================================================================
 // VerilatedTraceOffloadBuffer
 
-template <>  //
+template <>
 VerilatedTraceOffloadBuffer<VL_BUF_T>::VerilatedTraceOffloadBuffer(VL_SUB_T& owner)
     : VerilatedTraceBuffer<VL_BUF_T>{owner}
     , m_offloadBufferWritep{owner.m_offloadBufferWritep}

include/verilated_types.h

@@ -194,7 +194,8 @@ public:
 
 static int _vl_cmp_w(int words, WDataInP const lwp, WDataInP const rwp) VL_MT_SAFE;
 
-template <std::size_t T_Words> struct VlWide final {
+template <std::size_t T_Words>
+struct VlWide final {
     // MEMBERS
     // This should be the only data member, otherwise generated static initializers need updating
     EData m_storage[T_Words];  // Contents of the packed array
@@ -226,7 +227,8 @@ VlWide<T_Words>& VL_CVT_W_A(const WDataInP inp, const VlWide<T_Words>&) {
     return *((VlWide<T_Words>*)inp);
 }
 
-template <std::size_t T_Words> std::string VL_TO_STRING(const VlWide<T_Words>& obj) {
+template <std::size_t T_Words>
+std::string VL_TO_STRING(const VlWide<T_Words>& obj) {
     return VL_TO_STRING_W(T_Words, obj.data());
 }
 
@@ -237,7 +239,8 @@ template <std::size_t T_Words> std::string VL_TO_STRING(const VlWide<T_Words>& o
 //
 // Bound here is the maximum size() allowed, e.g. 1 + SystemVerilog bound
 // For dynamic arrays it is always zero
-template <class T_Value, size_t T_MaxSize = 0> class VlQueue final {
+template <class T_Value, size_t T_MaxSize = 0>
+class VlQueue final {
 private:
     // TYPES
     using Deque = std::deque<T_Value>;
@@ -262,7 +265,8 @@ public:
 
     // Standard copy constructor works. Verilog: assoca = assocb
     // Also must allow conversion from a different T_MaxSize queue
-    template <size_t U_MaxSize = 0> VlQueue operator=(const VlQueue<T_Value, U_MaxSize>& rhs) {
+    template <size_t U_MaxSize = 0>
+    VlQueue operator=(const VlQueue<T_Value, U_MaxSize>& rhs) {
         m_deque = rhs.privateDeque();
         if (VL_UNLIKELY(T_MaxSize && T_MaxSize < m_deque.size())) m_deque.resize(T_MaxSize - 1);
         return *this;
@@ -393,7 +397,8 @@ public:
 
     // Methods
     void sort() { std::sort(m_deque.begin(), m_deque.end()); }
-    template <typename Func> void sort(Func with_func) {
+    template <typename Func>
+    void sort(Func with_func) {
         // with_func returns arbitrary type to use for the sort comparison
         std::sort(m_deque.begin(), m_deque.end(), [=](const T_Value& a, const T_Value& b) {
             // index number is meaninless with sort, as it changes
@@ -401,7 +406,8 @@ public:
         });
     }
     void rsort() { std::sort(m_deque.rbegin(), m_deque.rend()); }
-    template <typename Func> void rsort(Func with_func) {
+    template <typename Func>
+    void rsort(Func with_func) {
         // with_func returns arbitrary type to use for the sort comparison
         std::sort(m_deque.rbegin(), m_deque.rend(), [=](const T_Value& a, const T_Value& b) {
             // index number is meaninless with sort, as it changes
@@ -436,7 +442,8 @@ public:
         }
         return out;
     }
-    template <typename Func> VlQueue find(Func with_func) const {
+    template <typename Func>
+    VlQueue find(Func with_func) const {
         VlQueue out;
         IData index = 0;
         for (const auto& i : m_deque) {
@@ -445,7 +452,8 @@ public:
         }
         return out;
     }
-    template <typename Func> VlQueue<IData> find_index(Func with_func) const {
+    template <typename Func>
+    VlQueue<IData> find_index(Func with_func) const {
         VlQueue<IData> out;
         IData index = 0;
         for (const auto& i : m_deque) {
@@ -454,7 +462,8 @@ public:
         }
         return out;
     }
-    template <typename Func> VlQueue find_first(Func with_func) const {
+    template <typename Func>
+    VlQueue find_first(Func with_func) const {
         // Can't use std::find_if as need index number
         IData index = 0;
         for (const auto& i : m_deque) {
@@ -463,7 +472,8 @@ public:
         }
         return VlQueue{};
     }
-    template <typename Func> VlQueue<IData> find_first_index(Func with_func) const {
+    template <typename Func>
+    VlQueue<IData> find_first_index(Func with_func) const {
         IData index = 0;
         for (const auto& i : m_deque) {
             if (with_func(index, i)) return VlQueue<IData>::cons(index);
@@ -471,7 +481,8 @@ public:
         }
         return VlQueue<IData>{};
     }
-    template <typename Func> VlQueue find_last(Func with_func) const {
+    template <typename Func>
+    VlQueue find_last(Func with_func) const {
         IData index = m_deque.size() - 1;
         for (auto& item : vlstd::reverse_view(m_deque)) {
             if (with_func(index, item)) return VlQueue::cons(item);
@@ -479,7 +490,8 @@ public:
         }
         return VlQueue{};
     }
-    template <typename Func> VlQueue<IData> find_last_index(Func with_func) const {
+    template <typename Func>
+    VlQueue<IData> find_last_index(Func with_func) const {
         IData index = m_deque.size() - 1;
         for (auto& item : vlstd::reverse_view(m_deque)) {
             if (with_func(index, item)) return VlQueue<IData>::cons(index);
@@ -505,7 +517,8 @@ public:
         for (const auto& i : m_deque) out += i;
         return out;
     }
-    template <typename Func> T_Value r_sum(Func with_func) const {
+    template <typename Func>
+    T_Value r_sum(Func with_func) const {
         T_Value out(0);  // Type must have assignment operator
         IData index = 0;
         for (const auto& i : m_deque) out += with_func(index++, i);
@@ -519,7 +532,8 @@ public:
         for (; it != m_deque.end(); ++it) out *= *it;
         return out;
     }
-    template <typename Func> T_Value r_product(Func with_func) const {
+    template <typename Func>
+    T_Value r_product(Func with_func) const {
         if (m_deque.empty()) return T_Value(0);
         auto it = m_deque.begin();
         IData index = 0;
@@ -537,7 +551,8 @@ public:
         for (; it != m_deque.end(); ++it) out &= *it;
         return out;
     }
-    template <typename Func> T_Value r_and(Func with_func) const {
+    template <typename Func>
+    T_Value r_and(Func with_func) const {
         if (m_deque.empty()) return T_Value(0);
         auto it = m_deque.begin();
         IData index = 0;
@@ -552,7 +567,8 @@ public:
         for (const auto& i : m_deque) out |= i;
         return out;
     }
-    template <typename Func> T_Value r_or(Func with_func) const {
+    template <typename Func>
+    T_Value r_or(Func with_func) const {
         T_Value out(0);  // Type must have assignment operator
         IData index = 0;
         for (const auto& i : m_deque) out |= with_func(index++, i);
@@ -563,7 +579,8 @@ public:
         for (const auto& i : m_deque) out ^= i;
         return out;
     }
-    template <typename Func> T_Value r_xor(Func with_func) const {
+    template <typename Func>
+    T_Value r_xor(Func with_func) const {
         T_Value out(0);  // Type must have assignment operator
         IData index = 0;
         for (const auto& i : m_deque) out ^= with_func(index++, i);
@@ -583,7 +600,8 @@ public:
     }
 };
 
-template <class T_Value> std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
+template <class T_Value>
+std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
     return obj.to_string();
 }
 
@@ -592,7 +610,8 @@ template <class T_Value> std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
 // There are no multithreaded locks on this; the base variable must
 // be protected by other means
 //
-template <class T_Key, class T_Value> class VlAssocArray final {
+template <class T_Key, class T_Value>
+class VlAssocArray final {
 private:
     // TYPES
     using Map = std::map<T_Key, T_Value>;
@@ -717,19 +736,22 @@ public:
         }
         return out;
     }
-    template <typename Func> VlQueue<T_Value> find(Func with_func) const {
+    template <typename Func>
+    VlQueue<T_Value> find(Func with_func) const {
         VlQueue<T_Value> out;
         for (const auto& i : m_map)
             if (with_func(i.first, i.second)) out.push_back(i.second);
         return out;
     }
-    template <typename Func> VlQueue<T_Key> find_index(Func with_func) const {
+    template <typename Func>
+    VlQueue<T_Key> find_index(Func with_func) const {
         VlQueue<T_Key> out;
         for (const auto& i : m_map)
             if (with_func(i.first, i.second)) out.push_back(i.first);
         return out;
     }
-    template <typename Func> VlQueue<T_Value> find_first(Func with_func) const {
+    template <typename Func>
+    VlQueue<T_Value> find_first(Func with_func) const {
         const auto it
             = std::find_if(m_map.begin(), m_map.end(), [=](const std::pair<T_Key, T_Value>& i) {
                   return with_func(i.first, i.second);
@@ -737,7 +759,8 @@ public:
         if (it == m_map.end()) return VlQueue<T_Value>{};
         return VlQueue<T_Value>::cons(it->second);
     }
-    template <typename Func> VlQueue<T_Key> find_first_index(Func with_func) const {
+    template <typename Func>
+    VlQueue<T_Key> find_first_index(Func with_func) const {
         const auto it
             = std::find_if(m_map.begin(), m_map.end(), [=](const std::pair<T_Key, T_Value>& i) {
                   return with_func(i.first, i.second);
@@ -745,7 +768,8 @@ public:
         if (it == m_map.end()) return VlQueue<T_Value>{};
         return VlQueue<T_Key>::cons(it->first);
     }
-    template <typename Func> VlQueue<T_Value> find_last(Func with_func) const {
+    template <typename Func>
+    VlQueue<T_Value> find_last(Func with_func) const {
         const auto it
             = std::find_if(m_map.rbegin(), m_map.rend(), [=](const std::pair<T_Key, T_Value>& i) {
                   return with_func(i.first, i.second);
@@ -753,7 +777,8 @@ public:
         if (it == m_map.rend()) return VlQueue<T_Value>{};
         return VlQueue<T_Value>::cons(it->second);
     }
-    template <typename Func> VlQueue<T_Key> find_last_index(Func with_func) const {
+    template <typename Func>
+    VlQueue<T_Key> find_last_index(Func with_func) const {
         const auto it
             = std::find_if(m_map.rbegin(), m_map.rend(), [=](const std::pair<T_Key, T_Value>& i) {
                   return with_func(i.first, i.second);
@@ -787,7 +812,8 @@ public:
         for (const auto& i : m_map) out += i.second;
         return out;
     }
-    template <typename Func> T_Value r_sum(Func with_func) const {
+    template <typename Func>
+    T_Value r_sum(Func with_func) const {
         T_Value out(0);  // Type must have assignment operator
         for (const auto& i : m_map) out += with_func(i.first, i.second);
         return out;
@@ -800,7 +826,8 @@ public:
         for (; it != m_map.end(); ++it) out *= it->second;
         return out;
     }
-    template <typename Func> T_Value r_product(Func with_func) const {
+    template <typename Func>
+    T_Value r_product(Func with_func) const {
         if (m_map.empty()) return T_Value(0);
         auto it = m_map.begin();
         T_Value out{with_func(it->first, it->second)};
@@ -816,7 +843,8 @@ public:
         for (; it != m_map.end(); ++it) out &= it->second;
         return out;
     }
-    template <typename Func> T_Value r_and(Func with_func) const {
+    template <typename Func>
+    T_Value r_and(Func with_func) const {
         if (m_map.empty()) return T_Value(0);
         auto it = m_map.begin();
         T_Value out{with_func(it->first, it->second)};
@@ -829,7 +857,8 @@ public:
         for (const auto& i : m_map) out |= i.second;
         return out;
     }
-    template <typename Func> T_Value r_or(Func with_func) const {
+    template <typename Func>
+    T_Value r_or(Func with_func) const {
         T_Value out(0);  // Type must have assignment operator
         for (const auto& i : m_map) out |= with_func(i.first, i.second);
         return out;
@@ -839,7 +868,8 @@ public:
         for (const auto& i : m_map) out ^= i.second;
         return out;
     }
-    template <typename Func> T_Value r_xor(Func with_func) const {
+    template <typename Func>
+    T_Value r_xor(Func with_func) const {
         T_Value out(0);  // Type must have assignment operator
         for (const auto& i : m_map) out ^= with_func(i.first, i.second);
         return out;
@@ -902,7 +932,8 @@ void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
 /// This class may get exposed to a Verilated Model's top I/O, if the top
 /// IO has an unpacked array.
 
-template <class T_Value, std::size_t T_Depth> struct VlUnpacked final {
+template <class T_Value, std::size_t T_Depth>
+struct VlUnpacked final {
     // MEMBERS
     // This should be the only data member, otherwise generated static initializers need updating
     T_Value m_storage[T_Depth];  // Contents of the unpacked array

include/verilated_vcd_c.cpp

@@ -65,7 +65,8 @@ constexpr unsigned VL_TRACE_SUFFIX_ENTRY_SIZE = 8;  // Size of a suffix entry
 //=============================================================================
 // Utility functions: TODO: put these in a common place and share them.
 
-template <size_t N> static size_t roundUpToMultipleOf(size_t value) {
+template <size_t N>
+static size_t roundUpToMultipleOf(size_t value) {
     static_assert((N & (N - 1)) == 0, "'N' must be a power of 2");
     size_t mask = N - 1;
     return (value + mask) & ~mask;

include/verilated_vcd_c.h

@@ -151,12 +151,18 @@ public:
 
 #ifndef DOXYGEN
 // Declare specialization here as it's used in VerilatedFstC just below
-template <> void VerilatedVcd::Super::dump(uint64_t time);
-template <> void VerilatedVcd::Super::set_time_unit(const char* unitp);
-template <> void VerilatedVcd::Super::set_time_unit(const std::string& unit);
-template <> void VerilatedVcd::Super::set_time_resolution(const char* unitp);
-template <> void VerilatedVcd::Super::set_time_resolution(const std::string& unit);
-template <> void VerilatedVcd::Super::dumpvars(int level, const std::string& hier);
+template <>
+void VerilatedVcd::Super::dump(uint64_t time);
+template <>
+void VerilatedVcd::Super::set_time_unit(const char* unitp);
+template <>
+void VerilatedVcd::Super::set_time_unit(const std::string& unit);
+template <>
+void VerilatedVcd::Super::set_time_resolution(const char* unitp);
+template <>
+void VerilatedVcd::Super::set_time_resolution(const std::string& unit);
+template <>
+void VerilatedVcd::Super::dumpvars(int level, const std::string& hier);
 #endif  // DOXYGEN
 
 //=============================================================================

include/verilated_vcd_sc.cpp

@@ -22,6 +22,7 @@
 //=============================================================================
 
 #include "verilatedos.h"
+
 #include "verilated_vcd_sc.h"
 
 //======================================================================

include/verilated_vcd_sc.h

@@ -23,6 +23,7 @@
 #define VERILATOR_VERILATED_VCD_SC_H_
 
 #include "verilatedos.h"
+
 #include "verilated_sc.h"
 #include "verilated_vcd_c.h"
 

include/verilated_vpi.cpp

@@ -26,8 +26,9 @@
 
 #define VERILATOR_VERILATED_VPI_CPP_
 
-#include "verilated.h"
 #include "verilated_vpi.h"
+
+#include "verilated.h"
 #include "verilated_imp.h"
 
 #include <list>

include/verilated_vpi.h

@@ -25,6 +25,7 @@
 #define VERILATOR_VERILATED_VPI_H_
 
 #include "verilatedos.h"
+
 #include "verilated.h"
 #include "verilated_syms.h"
 

include/verilatedos.h

@@ -534,7 +534,8 @@ using ssize_t = uint32_t;  ///< signed size_t; returned from read()
 
 namespace vlstd {
 
-template <typename T> struct reverse_wrapper {
+template <typename T>
+struct reverse_wrapper {
     const T& m_v;
 
     explicit reverse_wrapper(const T& a_v)
@@ -544,10 +545,16 @@ template <typename T> struct reverse_wrapper {
 };
 
 // C++20's std::ranges::reverse_view
-template <typename T> reverse_wrapper<T> reverse_view(const T& v) { return reverse_wrapper<T>(v); }
+template <typename T>
+reverse_wrapper<T> reverse_view(const T& v) {
+    return reverse_wrapper<T>(v);
+}
 
 // C++17's std::as_const
-template <class T> T const& as_const(T& v) { return v; }
+template <class T>
+T const& as_const(T& v) {
+    return v;
+}
 };  // namespace vlstd
 
 //=========================================================================

src/V3Active.cpp

@@ -29,10 +29,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Active.h"
+
 #include "V3Ast.h"
 #include "V3Const.h"
+#include "V3Global.h"
 #include "V3Graph.h"
 
 #include <unordered_map>
@@ -240,14 +241,16 @@ private:
     virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
 
     // Specialized below for the special sensitivity classes
-    template <typename SenItemKind> AstActive*& getSpecialActive();
+    template <typename SenItemKind>
+    AstActive*& getSpecialActive();
 
 public:
     // METHODS
     AstScope* scopep() { return m_scopep; }
 
     // Return an AstActive sensitive to the given special sensitivity class
-    template <typename SenItemKind> AstActive* getSpecialActive(FileLine* fl) {
+    template <typename SenItemKind>
+    AstActive* getSpecialActive(FileLine* fl) {
         AstActive*& cachep = getSpecialActive<SenItemKind>();
         if (!cachep) {
             AstSenTree* const senTreep = new AstSenTree{fl, new AstSenItem{fl, SenItemKind{}}};
@@ -281,10 +284,22 @@ public:
     void main(AstScope* nodep) { iterate(nodep); }
 };
 
-template <> AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Static>() { return m_sActivep; }
-template <> AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Initial>() { return m_iActivep; }
-template <> AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Final>() { return m_fActivep; }
-template <> AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Combo>() { return m_cActivep; }
+template <>
+AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Static>() {
+    return m_sActivep;
+}
+template <>
+AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Initial>() {
+    return m_iActivep;
+}
+template <>
+AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Final>() {
+    return m_fActivep;
+}
+template <>
+AstActive*& ActiveNamer::getSpecialActive<AstSenItem::Combo>() {
+    return m_cActivep;
+}
 
 //######################################################################
 // Latch checking visitor
@@ -417,7 +432,8 @@ private:
     bool m_canBeComb = false;  // Whether current clocked process can be turned into a comb process
 
     // METHODS
-    template <typename T> void moveUnderSpecial(AstNode* nodep) {
+    template <typename T>
+    void moveUnderSpecial(AstNode* nodep) {
         AstActive* const wantactivep = m_namer.getSpecialActive<T>(nodep->fileline());
         nodep->unlinkFrBack();
         wantactivep->addStmtsp(nodep);

src/V3ActiveTop.cpp

@@ -26,11 +26,12 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3ActiveTop.h"
+
 #include "V3Ast.h"
-#include "V3SenTree.h"
 #include "V3Const.h"
+#include "V3Global.h"
+#include "V3SenTree.h"
 
 //######################################################################
 // Active class functions

src/V3Assert.cpp

@@ -17,9 +17,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Assert.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 #include "V3Stats.h"
 
 //######################################################################

src/V3Assert.h

@@ -20,8 +20,8 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Error.h"
 #include "V3Ast.h"
+#include "V3Error.h"
 
 //============================================================================
 

src/V3AssertPre.cpp

@@ -20,9 +20,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3AssertPre.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 //######################################################################
 // Assert class functions

src/V3Ast.cpp

@@ -18,10 +18,11 @@
 #include "verilatedos.h"
 
 #include "V3Ast.h"
-#include "V3File.h"
-#include "V3Global.h"
+
 #include "V3Broken.h"
 #include "V3EmitV.h"
+#include "V3File.h"
+#include "V3Global.h"
 #include "V3String.h"
 
 #include <iomanip>

src/V3Ast.h

@@ -20,11 +20,13 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
+#include "V3Broken.h"
 #include "V3Error.h"
 #include "V3FileLine.h"
-#include "V3Number.h"
 #include "V3Global.h"
-#include "V3Broken.h"
+#include "V3Number.h"
+
+#include "V3Ast__gen_classes.h"  // From ./astgen
 
 #include <cmath>
 #include <functional>
@@ -34,8 +36,6 @@
 #include <unordered_set>
 #include <utility>
 #include <vector>
-
-#include "V3Ast__gen_classes.h"  // From ./astgen
 // Things like:
 //   class V3AstNode;
 
@@ -1144,7 +1144,7 @@ public:
     explicit VNUser(void* p) { m_u.up = p; }
     ~VNUser() = default;
     // Casters
-    template <class T>  //
+    template <class T>
     typename std::enable_if<std::is_pointer<T>::value, T>::type to() const {
         return reinterpret_cast<T>(m_u.up);
     }
@@ -1868,10 +1868,12 @@ private:
 
     // For internal use only.
     // Note: specializations for particular node types are provided by 'astgen'
-    template <typename T> inline static bool privateTypeTest(const AstNode* nodep);
+    template <typename T>
+    inline static bool privateTypeTest(const AstNode* nodep);
 
     // For internal use only.
-    template <typename TargetType, typename DeclType> constexpr static bool uselessCast() {
+    template <typename TargetType, typename DeclType>
+    constexpr static bool uselessCast() {
         using NonRef = typename std::remove_reference<DeclType>::type;
         using NonPtr = typename std::remove_pointer<NonRef>::type;
         using NonCV = typename std::remove_cv<NonPtr>::type;
@@ -1879,7 +1881,8 @@ private:
     }
 
     // For internal use only.
-    template <typename TargetType, typename DeclType> constexpr static bool impossibleCast() {
+    template <typename TargetType, typename DeclType>
+    constexpr static bool impossibleCast() {
         using NonRef = typename std::remove_reference<DeclType>::type;
         using NonPtr = typename std::remove_pointer<NonRef>::type;
         using NonCV = typename std::remove_cv<NonPtr>::type;
@@ -1888,20 +1891,23 @@ private:
 
 public:
     // For use via the VN_IS macro only
-    template <typename T, typename E> inline static bool privateIs(const AstNode* nodep) {
+    template <typename T, typename E>
+    inline static bool privateIs(const AstNode* nodep) {
         static_assert(!uselessCast<T, E>(), "Unnecessary VN_IS, node known to have target type.");
         static_assert(!impossibleCast<T, E>(), "Unnecessary VN_IS, node cannot be this type.");
         return nodep && privateTypeTest<T>(nodep);
     }
 
     // For use via the VN_CAST macro only
-    template <typename T, typename E> inline static T* privateCast(AstNode* nodep) {
+    template <typename T, typename E>
+    inline static T* privateCast(AstNode* nodep) {
         static_assert(!uselessCast<T, E>(),
                       "Unnecessary VN_CAST, node known to have target type.");
         static_assert(!impossibleCast<T, E>(), "Unnecessary VN_CAST, node cannot be this type.");
         return nodep && privateTypeTest<T>(nodep) ? reinterpret_cast<T*>(nodep) : nullptr;
     }
-    template <typename T, typename E> inline static const T* privateCast(const AstNode* nodep) {
+    template <typename T, typename E>
+    inline static const T* privateCast(const AstNode* nodep) {
         static_assert(!uselessCast<T, E>(),
                       "Unnecessary VN_CAST, node known to have target type.");
         static_assert(!impossibleCast<T, E>(), "Unnecessary VN_CAST, node cannot be this type.");
@@ -1909,7 +1915,8 @@ public:
     }
 
     // For use via the VN_AS macro only
-    template <typename T, typename E> inline static T* privateAs(AstNode* nodep) {
+    template <typename T, typename E>
+    inline static T* privateAs(AstNode* nodep) {
         static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type.");
         static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
         UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,
@@ -1917,7 +1924,8 @@ public:
                                                                               << "'");
         return reinterpret_cast<T*>(nodep);
     }
-    template <typename T, typename E> inline static const T* privateAs(const AstNode* nodep) {
+    template <typename T, typename E>
+    inline static const T* privateAs(const AstNode* nodep) {
         static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type.");
         static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
         UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,
@@ -1929,7 +1937,8 @@ public:
     // Predicate that returns true if the given 'nodep' might have a descendant of type 'T_Node'.
     // This is conservative and is used to speed up traversals.
     // Note: specializations for particular node types are provided below
-    template <typename T_Node> static bool mayBeUnder(const AstNode* nodep) {
+    template <typename T_Node>
+    static bool mayBeUnder(const AstNode* nodep) {
         static_assert(!std::is_const<T_Node>::value,
                       "Type parameter 'T_Node' should not be const qualified");
         static_assert(std::is_base_of<AstNode, T_Node>::value,
@@ -1940,7 +1949,8 @@ public:
     // Predicate that is true for node subtypes 'T_Node' that do not have any children
     // This is conservative and is used to speed up traversals.
     // Note: specializations for particular node types are provided below
-    template <typename T_Node> static constexpr bool isLeaf() {
+    template <typename T_Node>
+    static constexpr bool isLeaf() {
         static_assert(!std::is_const<T_Node>::value,
                       "Type parameter 'T_Node' should not be const qualified");
         static_assert(std::is_base_of<AstNode, T_Node>::value,
@@ -1962,7 +1972,8 @@ private:
     inline static bool predicateImpl(ConstCorrectAstNode<T_Arg>* nodep,
                                      const std::function<bool(T_Arg*)>& p);
 
-    template <typename T_Node> constexpr static bool checkTypeParameter() {
+    template <typename T_Node>
+    constexpr static bool checkTypeParameter() {
         static_assert(!std::is_const<T_Node>::value,
                       "Type parameter 'T_Node' should not be const qualified");
         static_assert(std::is_base_of<AstNode, T_Node>::value,
@@ -1977,25 +1988,29 @@ public:
     // handle a single (or a few) node types, as it's easier to write, but more importantly, the
     // dispatch to the operation function in 'foreach' should be completely predictable by branch
     // target caches in modern CPUs, while it is basically unpredictable for VNVisitor.
-    template <typename T_Node> void foreach (std::function<void(T_Node*)> f) {
+    template <typename T_Node>
+    void foreach (std::function<void(T_Node*)> f) {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         foreachImpl<T_Node>(this, f, /* visitNext: */ false);
     }
 
     // Same as above, but for 'const' nodes
-    template <typename T_Node> void foreach (std::function<void(const T_Node*)> f) const {
+    template <typename T_Node>
+    void foreach (std::function<void(const T_Node*)> f) const {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         foreachImpl<const T_Node>(this, f, /* visitNext: */ false);
     }
 
     // Same as 'foreach' but also follows 'this->nextp()'
-    template <typename T_Node> void foreachAndNext(std::function<void(T_Node*)> f) {
+    template <typename T_Node>
+    void foreachAndNext(std::function<void(T_Node*)> f) {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         foreachImpl<T_Node>(this, f, /* visitNext: */ true);
     }
 
     // Same as 'foreach' but also follows 'this->nextp()'
-    template <typename T_Node> void foreachAndNext(std::function<void(const T_Node*)> f) const {
+    template <typename T_Node>
+    void foreachAndNext(std::function<void(const T_Node*)> f) const {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         foreachImpl<const T_Node>(this, f, /* visitNext: */ true);
     }
@@ -2004,13 +2019,15 @@ public:
     // 'T_Node' that satisfies the predicate 'p'. Returns false if no node of type 'T_Node' is
     // present. Traversal is performed in some arbitrary order and is terminated as soon as the
     // result can be determined.
-    template <typename T_Node> bool exists(std::function<bool(T_Node*)> p) {
+    template <typename T_Node>
+    bool exists(std::function<bool(T_Node*)> p) {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         return predicateImpl<T_Node, /* Default: */ false>(this, p);
     }
 
     // Same as above, but for 'const' nodes
-    template <typename T_Node> void exists(std::function<bool(const T_Node*)> p) const {
+    template <typename T_Node>
+    void exists(std::function<bool(const T_Node*)> p) const {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         return predicateImpl<const T_Node, /* Default: */ false>(this, p);
     }
@@ -2019,13 +2036,15 @@ public:
     // 'T_Node' satisfy the predicate 'p'. Returns true if no node of type 'T_Node' is
     // present. Traversal is performed in some arbitrary order and is terminated as soon as the
     // result can be determined.
-    template <typename T_Node> bool forall(std::function<bool(T_Node*)> p) {
+    template <typename T_Node>
+    bool forall(std::function<bool(T_Node*)> p) {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         return predicateImpl<T_Node, /* Default: */ true>(this, p);
     }
 
     // Same as above, but for 'const' nodes
-    template <typename T_Node> void forall(std::function<bool(const T_Node*)> p) const {
+    template <typename T_Node>
+    void forall(std::function<bool(const T_Node*)> p) const {
         static_assert(checkTypeParameter<T_Node>(), "Invalid type parameter 'T_Node'");
         return predicateImpl<const T_Node, /* Default: */ true>(this, p);
     }
@@ -2042,13 +2061,16 @@ public:
 #include "V3Ast__gen_impl.h"  // From ./astgen
 
 // Specializations of AstNode::mayBeUnder
-template <> inline bool AstNode::mayBeUnder<AstCell>(const AstNode* nodep) {
+template <>
+inline bool AstNode::mayBeUnder<AstCell>(const AstNode* nodep) {
     return !VN_IS(nodep, NodeStmt) && !VN_IS(nodep, NodeMath);
 }
-template <> inline bool AstNode::mayBeUnder<AstNodeAssign>(const AstNode* nodep) {
+template <>
+inline bool AstNode::mayBeUnder<AstNodeAssign>(const AstNode* nodep) {
     return !VN_IS(nodep, NodeMath);
 }
-template <> inline bool AstNode::mayBeUnder<AstVarScope>(const AstNode* nodep) {
+template <>
+inline bool AstNode::mayBeUnder<AstVarScope>(const AstNode* nodep) {
     if (VN_IS(nodep, VarScope)) return false;  // Should not nest
     if (VN_IS(nodep, Var)) return false;
     if (VN_IS(nodep, Active)) return false;
@@ -2056,25 +2078,38 @@ template <> inline bool AstNode::mayBeUnder<AstVarScope>(const AstNode* nodep) {
     if (VN_IS(nodep, NodeMath)) return false;
     return true;
 }
-template <> inline bool AstNode::mayBeUnder<AstExecGraph>(const AstNode* nodep) {
+template <>
+inline bool AstNode::mayBeUnder<AstExecGraph>(const AstNode* nodep) {
     if (VN_IS(nodep, ExecGraph)) return false;  // Should not nest
     if (VN_IS(nodep, NodeStmt)) return false;  // Should be directly under CFunc
     return true;
 }
-template <> inline bool AstNode::mayBeUnder<AstActive>(const AstNode* nodep) {
+template <>
+inline bool AstNode::mayBeUnder<AstActive>(const AstNode* nodep) {
     return !VN_IS(nodep, Active);  // AstActives do not nest
 }
-template <> inline bool AstNode::mayBeUnder<AstScope>(const AstNode* nodep) {
+template <>
+inline bool AstNode::mayBeUnder<AstScope>(const AstNode* nodep) {
     return !VN_IS(nodep, Scope);  // AstScopes do not nest
 }
-template <> inline bool AstNode::mayBeUnder<AstSenTree>(const AstNode* nodep) {
+template <>
+inline bool AstNode::mayBeUnder<AstSenTree>(const AstNode* nodep) {
     return !VN_IS(nodep, SenTree);  // AstSenTree do not nest
 }
 
 // Specializations of AstNode::isLeaf
-template <> constexpr bool AstNode::isLeaf<AstNodeVarRef>() { return true; }
-template <> constexpr bool AstNode::isLeaf<AstVarRef>() { return true; }
-template <> constexpr bool AstNode::isLeaf<AstVarXRef>() { return true; }
+template <>
+constexpr bool AstNode::isLeaf<AstNodeVarRef>() {
+    return true;
+}
+template <>
+constexpr bool AstNode::isLeaf<AstVarRef>() {
+    return true;
+}
+template <>
+constexpr bool AstNode::isLeaf<AstVarXRef>() {
+    return true;
+}
 
 // foreach implementation
 template <typename T_Arg>
@@ -2258,7 +2293,7 @@ inline void VNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
 //######################################################################
 
 // VNRef is std::reference_wrapper that can only hold AstNode subtypes
-template <typename T_Node>  //
+template <typename T_Node>
 class VNRef final : public std::reference_wrapper<T_Node> {
     static_assert(std::is_base_of<AstNode, T_Node>::value,
                   "Type parameter 'T_Node' must be a subtype of AstNode");
@@ -2284,13 +2319,13 @@ static_assert(sizeof(VNRef<AstNode>) == sizeof(std::reference_wrapper<AstNode>),
 size_t V3HasherUncachedHash(const AstNode&);
 
 // Specialization of std::hash for VNRef
-template <typename T_Node>  //
+template <typename T_Node>
 struct std::hash<VNRef<T_Node>> final {
     size_t operator()(VNRef<T_Node> r) const { return V3HasherUncachedHash(r); }
 };
 
 // Specialization of std::equal_to for VNRef
-template <typename T_Node>  //
+template <typename T_Node>
 struct std::equal_to<VNRef<T_Node>> final {
     size_t operator()(VNRef<T_Node> ra, VNRef<T_Node> rb) const {
         return ra.get().sameTree(&(rb.get()));

src/V3AstUserAllocator.h

@@ -27,7 +27,8 @@
 #include <utility>
 #include <vector>
 
-template <class T_Node, class T_Data, int T_UserN> class AstUserAllocatorBase VL_NOT_FINAL {
+template <class T_Node, class T_Data, int T_UserN>
+class AstUserAllocatorBase VL_NOT_FINAL {
     static_assert(1 <= T_UserN && T_UserN <= 5, "Wrong user pointer number");
     static_assert(std::is_base_of<AstNode, T_Node>::value, "T_Node must be an AstNode type");
 
@@ -91,7 +92,7 @@ protected:
 
 public:
     // Get a reference to the user data. If does not exist, construct it with given arguments.
-    template <typename... Args>  //
+    template <typename... Args>
     T_Data& operator()(T_Node* nodep, Args&&... args) {
         T_Data* userp = getUserp(nodep);
         if (!userp) {

src/V3Begin.cpp

@@ -28,9 +28,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Begin.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 #include <algorithm>
 

src/V3Branch.cpp

@@ -26,9 +26,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Branch.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 #include <map>
 

src/V3Broken.cpp

@@ -25,9 +25,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Broken.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 // This visitor does not edit nodes, and is called at error-exit, so should use constant iterators
 #include "V3AstConstOnly.h"

src/V3CCtors.cpp

@@ -27,10 +27,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
-#include "V3EmitCBase.h"
 #include "V3CCtors.h"
 
+#include "V3EmitCBase.h"
+#include "V3Global.h"
+
 #include <algorithm>
 #include <list>
 

src/V3CUse.cpp

@@ -25,9 +25,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3CUse.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 #include <set>
 

src/V3Case.cpp

@@ -37,9 +37,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Case.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 #include "V3Stats.h"
 
 #include <algorithm>

src/V3Cast.cpp

@@ -40,9 +40,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Cast.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 #include <algorithm>
 

src/V3Cdc.cpp

@@ -24,13 +24,14 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Cdc.h"
+
 #include "V3Ast.h"
-#include "V3Graph.h"
 #include "V3Const.h"
 #include "V3EmitV.h"
 #include "V3File.h"
+#include "V3Global.h"
+#include "V3Graph.h"
 
 #include <algorithm>
 #include <deque>

src/V3Class.cpp

@@ -23,9 +23,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Class.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 //######################################################################
 

src/V3Clean.cpp

@@ -26,9 +26,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Clean.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 #include <algorithm>
 

src/V3Clock.cpp

@@ -30,9 +30,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Clock.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 #include "V3Sched.h"
 
 #include <algorithm>

src/V3Combine.cpp

@@ -22,12 +22,13 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Combine.h"
-#include "V3DupFinder.h"
-#include "V3Stats.h"
+
 #include "V3Ast.h"
 #include "V3AstUserAllocator.h"
+#include "V3DupFinder.h"
+#include "V3Global.h"
+#include "V3Stats.h"
 
 #include <list>
 #include <vector>

src/V3Common.cpp

@@ -24,9 +24,10 @@
 #include "verilatedos.h"
 
 #include "V3Common.h"
+
 #include "V3Ast.h"
-#include "V3Global.h"
 #include "V3EmitCBase.h"
+#include "V3Global.h"
 
 //######################################################################
 // Common component builders

src/V3Config.cpp

@@ -17,9 +17,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
+#include "V3Config.h"
+
 #include "V3Global.h"
 #include "V3String.h"
-#include "V3Config.h"
 
 #include <map>
 #include <set>
@@ -33,7 +34,8 @@
 // as wildcards and are accessed by a resolved name. It rebuilds a name lookup
 // cache of resolved entities. Entities stored in this container need an update
 // function that takes a reference of this type to join multiple entities into one.
-template <typename T> class V3ConfigWildcardResolver {
+template <typename T>
+class V3ConfigWildcardResolver final {
     using Map = std::map<const std::string, T>;
 
     Map m_mapWildcard;  // Wildcard strings to entities

src/V3Config.h

@@ -20,9 +20,9 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
+#include "V3Ast.h"
 #include "V3Error.h"
 #include "V3FileLine.h"
-#include "V3Ast.h"
 
 //######################################################################
 

src/V3Const.cpp

@@ -23,14 +23,15 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
-#include "V3String.h"
 #include "V3Const.h"
+
 #include "V3Ast.h"
-#include "V3Width.h"
+#include "V3Global.h"
 #include "V3Simulate.h"
 #include "V3Stats.h"
+#include "V3String.h"
 #include "V3UniqueNames.h"
+#include "V3Width.h"
 
 #include <algorithm>
 #include <memory>

src/V3Coverage.cpp

@@ -27,9 +27,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Coverage.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 #include <map>
 #include <unordered_map>

src/V3CoverageJoin.cpp

@@ -20,9 +20,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3CoverageJoin.h"
+
 #include "V3DupFinder.h"
+#include "V3Global.h"
 #include "V3Stats.h"
 
 #include <vector>

src/V3Dead.cpp

@@ -36,9 +36,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Dead.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 
 #include <map>
 #include <vector>

src/V3Delayed.cpp

@@ -51,9 +51,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Delayed.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 #include "V3Stats.h"
 
 #include <algorithm>

src/V3Depth.cpp

@@ -26,9 +26,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Depth.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 #include "V3UniqueNames.h"
 
 #include <algorithm>

src/V3DepthBlock.cpp

@@ -23,10 +23,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3DepthBlock.h"
+
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
+#include "V3Global.h"
 
 #include <algorithm>
 

src/V3Descope.cpp

@@ -25,10 +25,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Descope.h"
+
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
+#include "V3Global.h"
 
 #include <map>
 

src/V3DupFinder.cpp

@@ -17,10 +17,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3DupFinder.h"
+
 #include "V3Ast.h"
 #include "V3File.h"
+#include "V3Global.h"
 
 #include <algorithm>
 #include <iomanip>

src/V3DupFinder.h

@@ -23,8 +23,8 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Error.h"
 #include "V3Ast.h"
+#include "V3Error.h"
 #include "V3Hasher.h"
 
 #include <map>

src/V3EmitCBase.cpp

@@ -18,6 +18,7 @@
 #include "verilatedos.h"
 
 #include "V3EmitCBase.h"
+
 #include "V3Task.h"
 
 //######################################################################

src/V3EmitCBase.h

@@ -20,12 +20,12 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
-#include "V3File.h"
 #include "V3Ast.h"
+#include "V3File.h"
+#include "V3Global.h"
 
-#include <cstdarg>
 #include <cmath>
+#include <cstdarg>
 
 //######################################################################
 // Set user4p in all CFunc and Var to point to the containing AstNodeModule

src/V3EmitCConstPool.cpp

@@ -21,8 +21,8 @@
 #include "V3EmitCConstInit.h"
 #include "V3File.h"
 #include "V3Global.h"
-#include "V3String.h"
 #include "V3Stats.h"
+#include "V3String.h"
 
 #include <algorithm>
 #include <cinttypes>

src/V3EmitCFunc.cpp

@@ -17,9 +17,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
+#include "V3EmitCFunc.h"
+
 #include "V3Global.h"
 #include "V3String.h"
-#include "V3EmitCFunc.h"
 #include "V3TSP.h"
 
 #include <map>

src/V3EmitCFunc.h

@@ -20,8 +20,8 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3EmitCConstInit.h"
+#include "V3Global.h"
 
 #include <algorithm>
 #include <map>

src/V3EmitCHeaders.cpp

@@ -17,9 +17,9 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3EmitC.h"
 #include "V3EmitCConstInit.h"
+#include "V3Global.h"
 
 #include <algorithm>
 #include <vector>

src/V3EmitCImp.cpp

@@ -17,10 +17,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
-#include "V3EmitC.h"
 #include "V3Ast.h"
+#include "V3EmitC.h"
 #include "V3EmitCFunc.h"
+#include "V3Global.h"
 #include "V3String.h"
 #include "V3UniqueNames.h"
 

src/V3EmitCInlines.cpp

@@ -17,9 +17,9 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3EmitC.h"
 #include "V3EmitCBase.h"
+#include "V3Global.h"
 #include "V3Stats.h"
 
 #include <map>

src/V3EmitCMain.cpp

@@ -17,10 +17,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
+#include "V3EmitCMain.h"
+
 #include "V3EmitC.h"
 #include "V3EmitCBase.h"
-#include "V3EmitCMain.h"
+#include "V3Global.h"
 
 #include <map>
 

src/V3EmitCMake.cpp

@@ -17,11 +17,12 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
-#include "V3Os.h"
 #include "V3EmitCMake.h"
+
 #include "V3EmitCBase.h"
+#include "V3Global.h"
 #include "V3HierBlock.h"
+#include "V3Os.h"
 
 #include <memory>
 
@@ -36,7 +37,8 @@ class CMakeEmitter final {
     // STATIC FUNCTIONS
 
     // Concatenate all strings in 'strs' with ' ' between them.
-    template <typename List> static string cmake_list(const List& strs) {
+    template <typename List>
+    static string cmake_list(const List& strs) {
         string s;
         if (strs.begin() != strs.end()) {
             s.append("\"");

src/V3EmitCModel.cpp

@@ -17,9 +17,9 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3EmitC.h"
 #include "V3EmitCFunc.h"
+#include "V3Global.h"
 #include "V3UniqueNames.h"
 
 #include <algorithm>

src/V3EmitCSyms.cpp

@@ -17,9 +17,9 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3EmitC.h"
 #include "V3EmitCBase.h"
+#include "V3Global.h"
 #include "V3LanguageWords.h"
 #include "V3PartitionGraph.h"
 

src/V3EmitMk.cpp

@@ -17,11 +17,12 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
+#include "V3EmitMk.h"
+
+#include "V3EmitCBase.h"
 #include "V3Global.h"
 #include "V3HierBlock.h"
 #include "V3Os.h"
-#include "V3EmitMk.h"
-#include "V3EmitCBase.h"
 
 //######################################################################
 // Emit statements and math operators

src/V3EmitV.cpp

@@ -17,9 +17,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3EmitV.h"
+
 #include "V3EmitCBase.h"
+#include "V3Global.h"
 
 #include <algorithm>
 #include <map>

src/V3EmitXml.cpp

@@ -17,10 +17,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
+#include "V3EmitXml.h"
+
+#include "V3EmitCBase.h"
 #include "V3Global.h"
 #include "V3String.h"
-#include "V3EmitXml.h"
-#include "V3EmitCBase.h"
 
 #include <map>
 #include <vector>

src/V3Expand.cpp

@@ -28,11 +28,12 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Expand.h"
-#include "V3Stats.h"
+
 #include "V3Ast.h"
 #include "V3Const.h"
+#include "V3Global.h"
+#include "V3Stats.h"
 
 #include <algorithm>
 

src/V3File.cpp

@@ -17,11 +17,12 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3File.h"
+
+#include "V3Ast.h"
+#include "V3Global.h"
 #include "V3Os.h"
 #include "V3String.h"
-#include "V3Ast.h"
 
 #include <cerrno>
 #include <cstdarg>
@@ -29,6 +30,7 @@
 #include <iomanip>
 #include <map>
 #include <memory>
+
 #include <sys/stat.h>
 #include <sys/types.h>
 

src/V3File.h

@@ -23,12 +23,12 @@
 #include "V3Error.h"
 
 #include <array>
-#include <stack>
-#include <set>
-#include <list>
-#include <vector>
 #include <fstream>
+#include <list>
 #include <memory>
+#include <set>
+#include <stack>
+#include <vector>
 
 //============================================================================
 // V3File: Create streams, recording dependency information

src/V3FileLine.h

@@ -23,12 +23,12 @@
 #include "V3Error.h"
 #include "V3LangCode.h"
 
-#include <sstream>
 #include <bitset>
+#include <deque>
 #include <map>
 #include <memory>
 #include <set>
-#include <deque>
+#include <sstream>
 
 //######################################################################
 

src/V3Force.cpp

@@ -40,11 +40,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Error.h"
-#include "V3Global.h"
 #include "V3Force.h"
 
 #include "V3AstUserAllocator.h"
+#include "V3Error.h"
+#include "V3Global.h"
 
 //######################################################################
 // Convert force/release statements and signals marked 'forceable'

src/V3Gate.cpp

@@ -24,14 +24,15 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Gate.h"
+
 #include "V3Ast.h"
 #include "V3AstUserAllocator.h"
-#include "V3Graph.h"
 #include "V3Const.h"
-#include "V3Stats.h"
 #include "V3DupFinder.h"
+#include "V3Global.h"
+#include "V3Graph.h"
+#include "V3Stats.h"
 
 #include <algorithm>
 #include <list>

src/V3Global.cpp

@@ -18,6 +18,7 @@
 #include "verilatedos.h"
 
 #include "V3Global.h"
+
 #include "V3Ast.h"
 #include "V3File.h"
 #include "V3HierBlock.h"

src/V3Global.h

@@ -48,7 +48,8 @@ class V3HierBlockPlan;
 
 // Object used by VL_RESTORER.  This object must be an auto variable, not
 // allocated on the heap or otherwise.
-template <typename T> class VRestorer {
+template <typename T>
+class VRestorer final {
     T& m_ref;  // Reference to object we're saving and restoring
     const T m_saved;  // Value saved, for later restore
 

src/V3Graph.cpp

@@ -17,10 +17,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
-#include "V3File.h"
 #include "V3Graph.h"
 
+#include "V3File.h"
+#include "V3Global.h"
+
 #include <map>
 #include <memory>
 #include <unordered_map>

src/V3GraphAlg.cpp

@@ -17,14 +17,15 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3GraphAlg.h"
+
+#include "V3Global.h"
 #include "V3GraphPathChecker.h"
 
 #include <algorithm>
-#include <vector>
-#include <map>
 #include <list>
+#include <map>
+#include <vector>
 
 //######################################################################
 //######################################################################

src/V3GraphPathChecker.cpp

@@ -17,10 +17,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3GraphStream.h"
-#include "V3Global.h"
 #include "V3GraphPathChecker.h"
 
+#include "V3Global.h"
+#include "V3GraphStream.h"
+
 //######################################################################
 // GraphPCNode
 

src/V3GraphStream.h

@@ -39,7 +39,8 @@
 // not generally safe. If you want a raw pointer compare, see
 // GraphStreamUnordered below.
 
-template <class T_Compare> class GraphStream {
+template <class T_Compare>
+class GraphStream final {
 private:
     // TYPES
     class VxHolder final {

src/V3Hash.h

@@ -55,12 +55,16 @@ public:
     bool operator<(const V3Hash& rh) const { return m_value < rh.m_value; }
 
     // '+' combines hashes
-    template <class T> V3Hash operator+(T that) const {
+    template <class T>
+    V3Hash operator+(T that) const {
         return V3Hash(combine(m_value, V3Hash(that).m_value));
     }
 
     // '+=' combines in place
-    template <class T> V3Hash& operator+=(T that) { return *this = *this + that; }
+    template <class T>
+    V3Hash& operator+=(T that) {
+        return *this = *this + that;
+    }
 };
 
 std::ostream& operator<<(std::ostream& os, const V3Hash& rhs);

src/V3Hasher.h

@@ -23,8 +23,8 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Error.h"
 #include "V3Ast.h"
+#include "V3Error.h"
 #include "V3Hash.h"
 
 //============================================================================

src/V3HierBlock.cpp

@@ -72,18 +72,19 @@
 //       Used for b) and c).
 //       This options is repeated for all instantiating hierarchical blocks.
 
-#include <memory>
-#include <sstream>
-#include <utility>
-#include <vector>
+#include "V3HierBlock.h"
 
 #include "V3Ast.h"
 #include "V3Error.h"
 #include "V3File.h"
-#include "V3HierBlock.h"
 #include "V3Os.h"
-#include "V3String.h"
 #include "V3Stats.h"
+#include "V3String.h"
+
+#include <memory>
+#include <sstream>
+#include <utility>
+#include <vector>
 
 static string V3HierCommandArgsFileName(const string& prefix, bool forCMake) {
     return v3Global.opt.makeDir() + "/" + prefix

src/V3HierBlock.h

@@ -28,9 +28,9 @@
 #include <map>
 #include <set>
 #include <string>
-#include <utility>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 class AstNetlist;

src/V3Inline.cpp

@@ -27,15 +27,15 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Inline.h"
+
+#include "V3Ast.h"
+#include "V3AstUserAllocator.h"
+#include "V3Global.h"
 #include "V3Inst.h"
 #include "V3Stats.h"
-#include "V3Ast.h"
 #include "V3String.h"
 
-#include "V3AstUserAllocator.h"
-
 #include <algorithm>
 #include <unordered_set>
 #include <vector>

src/V3Inst.cpp

@@ -24,10 +24,11 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Inst.h"
+
 #include "V3Ast.h"
 #include "V3Const.h"
+#include "V3Global.h"
 
 #include <algorithm>
 

src/V3InstrCount.cpp

@@ -18,9 +18,10 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Ast.h"
 #include "V3InstrCount.h"
 
+#include "V3Ast.h"
+
 #include <iomanip>
 
 /// Estimate the instruction cost for executing all logic within and below

src/V3LangCode.h

@@ -20,9 +20,9 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include <vector>
 #include <map>
 #include <set>
+#include <vector>
 
 //######################################################################
 //! Class for the different languages supported.

src/V3Life.cpp

@@ -26,11 +26,12 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3Life.h"
-#include "V3Stats.h"
+
 #include "V3Ast.h"
 #include "V3Const.h"
+#include "V3Global.h"
+#include "V3Stats.h"
 
 #include <map>
 #include <vector>

src/V3LifePost.cpp

@@ -27,12 +27,13 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
-#include "V3PartitionGraph.h"
-#include "V3GraphPathChecker.h"
 #include "V3LifePost.h"
-#include "V3Stats.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
+#include "V3GraphPathChecker.h"
+#include "V3PartitionGraph.h"
+#include "V3Stats.h"
 
 #include <memory>  // for std::unique_ptr -> auto_ptr or unique_ptr
 #include <unordered_map>

src/V3LinkCells.cpp

@@ -26,17 +26,18 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3LinkCells.h"
-#include "V3SymTable.h"
-#include "V3Parse.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
 #include "V3Graph.h"
+#include "V3Parse.h"
+#include "V3SymTable.h"
 
 #include <algorithm>
 #include <map>
-#include <vector>
 #include <unordered_set>
+#include <vector>
 
 //######################################################################
 // Graph subclasses

src/V3LinkDot.cpp

@@ -64,12 +64,13 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Global.h"
 #include "V3LinkDot.h"
-#include "V3SymTable.h"
-#include "V3Graph.h"
+
 #include "V3Ast.h"
+#include "V3Global.h"
+#include "V3Graph.h"
 #include "V3String.h"
+#include "V3SymTable.h"
 
 #include <algorithm>
 #include <map>

src/V3LinkDot.h

@@ -20,8 +20,8 @@
 #include "config_build.h"
 #include "verilatedos.h"
 
-#include "V3Error.h"
 #include "V3Ast.h"
+#include "V3Error.h"
 
 //============================================================================