Internals: Restyle with C++11 using replacing typedef

include/verilated.cpp

@@ -2556,7 +2556,7 @@ const char* Verilated::catName(const char* n1, const char* n2, const char* delim
 
 // Keeping these out of class Verilated to avoid having to include <list>
 // in verilated.h (for compilation speed)
-typedef std::list<std::pair<Verilated::VoidPCb, void*>> VoidPCbList;
+using VoidPCbList = std::list<std::pair<Verilated::VoidPCb, void*>>;
 static struct {
     VerilatedMutex s_flushMutex;
     VoidPCbList s_flushCbs VL_GUARDED_BY(s_flushMutex);

include/verilated.h

@@ -569,10 +569,10 @@ public:  // But for internal use only
 
 class VerilatedScope final {
 public:
-    typedef enum : vluint8_t {
+    enum Type : vluint8_t {
         SCOPE_MODULE,
         SCOPE_OTHER
-    } Type;  // Type of a scope, currently module is only interesting
+    };  // Type of a scope, currently module is only interesting
 private:
     // Fastpath:
     VerilatedSyms* m_symsp = nullptr;  ///< Symbol table

include/verilated_cov.cpp

@@ -92,9 +92,9 @@ public:
 class VerilatedCovImp final : public VerilatedCovContext {
 private:
     // TYPES
-    typedef std::map<const std::string, int> ValueIndexMap;
-    typedef std::map<int, std::string> IndexValueMap;
-    typedef std::deque<VerilatedCovImpItem*> ItemList;
+    using ValueIndexMap = std::map<const std::string, int>;
+    using IndexValueMap = std::map<int, std::string>;
+    using ItemList = std::deque<VerilatedCovImpItem*>;
 
     // MEMBERS
     VerilatedMutex m_mutex;  ///< Protects all members
@@ -357,8 +357,7 @@ public:
         os << "# SystemC::Coverage-3\n";
 
         // Build list of events; totalize if collapsing hierarchy
-        typedef std::map<const std::string, std::pair<std::string, vluint64_t>> EventMap;
-        EventMap eventCounts;
+        std::map<const std::string, std::pair<std::string, vluint64_t>> eventCounts;
         for (const auto& itemp : m_items) {
             std::string name;
             std::string hier;

include/verilated_heavy.h

@@ -49,7 +49,7 @@ extern std::string VL_TO_STRING_W(int words, WDataInP obj);
 
 class VlURNG final {
 public:
-    typedef size_t result_type;
+    using result_type = size_t;
     static constexpr size_t min() { return 0; }
     static constexpr size_t max() { return 1ULL << 31; }
     size_t operator()() { return VL_MASK_I(31) & VL_RANDOM_I(32); }
@@ -142,10 +142,10 @@ template <std::size_t T_Words> std::string VL_TO_STRING(const VlWide<T_Words>& o
 template <class T_Value, size_t T_MaxSize = 0> class VlQueue final {
 private:
     // TYPES
-    typedef std::deque<T_Value> Deque;
+    using Deque = std::deque<T_Value>;
 
 public:
-    typedef typename Deque::const_iterator const_iterator;
+    using const_iterator = typename Deque::const_iterator;
 
 private:
     // MEMBERS
@@ -497,10 +497,10 @@ template <class T_Value> std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
 template <class T_Key, class T_Value> class VlAssocArray final {
 private:
     // TYPES
-    typedef std::map<T_Key, T_Value> Map;
+    using Map = std::map<T_Key, T_Value>;
 
 public:
-    typedef typename Map::const_iterator const_iterator;
+    using const_iterator = typename Map::const_iterator;
 
 private:
     // MEMBERS
@@ -801,10 +801,10 @@ void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
 template <class T_Value, std::size_t T_Depth> class VlUnpacked final {
 private:
     // TYPES
-    typedef std::array<T_Value, T_Depth> Array;
+    using Array = std::array<T_Value, T_Depth>;
 
 public:
-    typedef typename Array::const_iterator const_iterator;
+    using const_iterator = typename Array::const_iterator;
 
 private:
     // MEMBERS

include/verilated_imp.h

@@ -80,7 +80,7 @@ public:
 /// This assumes no thread starts pushing the next tick until the previous has drained.
 /// If more aggressiveness is needed, a double-buffered scheme might work well.
 class VerilatedEvalMsgQueue final {
-    typedef std::multiset<VerilatedMsg, VerilatedMsg::Cmp> VerilatedThreadQueue;
+    using VerilatedThreadQueue = std::multiset<VerilatedMsg, VerilatedMsg::Cmp>;
 
     std::atomic<vluint64_t> m_depth;  ///< Current depth of queue (see comments below)
 
@@ -180,7 +180,7 @@ class VerilatedFpList final {
     std::size_t m_sz = 0;
 
 public:
-    typedef FILE* const* const_iterator;
+    using const_iterator = FILE* const*;
     explicit VerilatedFpList() {}
     const_iterator begin() const { return m_fp; }
     const_iterator end() const { return m_fp + m_sz; }
@@ -398,8 +398,8 @@ protected:
     friend class VerilatedImp;
 
     // TYPES
-    typedef std::map<std::pair<const void*, void*>, void*> UserMap;
-    typedef std::map<const char*, int, VerilatedCStrCmp> ExportNameMap;
+    using UserMap = std::map<std::pair<const void*, void*>, void*>;
+    using ExportNameMap = std::map<const char*, int, VerilatedCStrCmp>;
 
     // MEMBERS
     // Nothing below here is save-restored; users expected to re-register appropriately

include/verilated_threads.h

@@ -47,9 +47,9 @@
 // VlMTaskVertex and VlThreadpool will work with multiple symbol table types.
 // Since the type is opaque to VlMTaskVertex and VlThreadPool, represent it
 // as a void* here.
-typedef void* VlThrSymTab;
+using VlThrSymTab = void*;
 
-typedef void (*VlExecFnp)(bool, VlThrSymTab);
+using VlExecFnp = void (*)(bool, VlThrSymTab);
 
 /// Track dependencies for a single MTask.
 class VlMTaskVertex final {
@@ -251,7 +251,7 @@ public:
 
 class VlThreadPool final {
     // TYPES
-    typedef std::vector<VlProfileRec> ProfileTrace;
+    using ProfileTrace = std::vector<VlProfileRec>;
 
     // MEMBERS
     std::vector<VlWorkerThread*> m_workers;  // our workers

include/verilated_trace.h

@@ -114,8 +114,8 @@ public:
     //=========================================================================
     // Generic tracing internals
 
-    typedef void (*initCb_t)(void*, T_Derived*, uint32_t);  // Type of init callbacks
-    typedef void (*dumpCb_t)(void*, T_Derived*);  // Type of all but init callbacks
+    using initCb_t = void (*)(void*, T_Derived*, vluint32_t);  // Type of init callbacks
+    using dumpCb_t = void (*)(void*, T_Derived*);  // Type of all but init callbacks
 
 private:
     struct CallbackRecord {

include/verilated_vcd_c.h

@@ -76,7 +76,7 @@ private:
     std::vector<char> m_suffixes;  ///< VCD line end string codes + metadata
     const char* m_suffixesp;  ///< Pointer to first element of above
 
-    typedef std::map<const std::string, const std::string> NameMap;
+    using NameMap = std::map<const std::string, const std::string>;
     NameMap* m_namemapp = nullptr;  ///< List of names for the header
 
     void bufferResize(vluint64_t minsize);

include/verilated_vpi.cpp

@@ -456,7 +456,7 @@ public:
 
 //======================================================================
 
-typedef PLI_INT32 (*VerilatedPliCb)(struct t_cb_data*);
+using VerilatedPliCb = PLI_INT32 (*)(struct t_cb_data*);
 
 class VerilatedVpiCbHolder final {
     // Holds information needed to call a callback
@@ -502,8 +502,8 @@ class VerilatedVpiError;
 
 class VerilatedVpiImp final {
     enum { CB_ENUM_MAX_VALUE = cbAtEndOfSimTime + 1 };  // Maxium callback reason
-    typedef std::list<VerilatedVpiCbHolder> VpioCbList;
-    typedef std::map<std::pair<QData, vluint64_t>, VerilatedVpiCbHolder> VpioTimedCbs;
+    using VpioCbList = std::list<VerilatedVpiCbHolder>;
+    using VpioTimedCbs = std::map<std::pair<QData, vluint64_t>, VerilatedVpiCbHolder>;
 
     // All only medium-speed, so use singleton function
     VpioCbList m_cbObjLists[CB_ENUM_MAX_VALUE];  // Callbacks for each supported reason

src/V3Active.cpp

@@ -211,7 +211,7 @@ private:
     AstActive* m_cActivep = nullptr;  // For current scope, the SActive(combo) we're building
 
     SenTreeSet m_activeSens;  // Sen lists for each active we've made
-    typedef std::unordered_map<AstSenTree*, AstActive*> ActiveMap;
+    using ActiveMap = std::unordered_map<AstSenTree*, AstActive*>;
     ActiveMap m_activeMap;  // Map sentree to active, for folding.
 
     // METHODS

src/V3Ast.h

@@ -42,7 +42,7 @@ class VFlagBitPacked {};
 class VFlagChildDType {};  // Used by parser.y to select constructor that sets childDType
 
 // Used as key for another map, needs operator<, hence not an unordered_set
-typedef std::set<int> MTaskIdSet;  // Set of mtaskIds for Var sorting
+using MTaskIdSet = std::set<int>;  // Set of mtaskIds for Var sorting
 
 //######################################################################
 
@@ -2468,7 +2468,7 @@ class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType {
     // A struct or union; common handling
 private:
     // TYPES
-    typedef std::map<const string, AstMemberDType*> MemberNameMap;
+    using MemberNameMap = std::map<const std::string, AstMemberDType*>;
     // MEMBERS
     string m_name;  // Name from upper typedef, if any
     bool m_packed;

src/V3AstNodes.h

@@ -296,7 +296,7 @@ public:
 
 class AstClass final : public AstNodeModule {
     // TYPES
-    typedef std::map<const string, AstNode*> MemberNameMap;
+    using MemberNameMap = std::map<const std::string, AstNode*>;
     // MEMBERS
     MemberNameMap m_members;  // Members or method children
     AstClassPackage* m_classOrPackagep = nullptr;  // Class package this is under
@@ -4980,7 +4980,7 @@ class AstInitArray final : public AstNode {
     // Parents: ASTVAR::init()
     // Children: AstInitItem
 public:
-    typedef std::map<uint32_t, AstInitItem*> KeyItemMap;
+    using KeyItemMap = std::map<uint32_t, AstInitItem*>;
 
 private:
     KeyItemMap m_map;  // Node value for each array index
@@ -9180,7 +9180,7 @@ class AstTypeTable final : public AstNode {
     AstQueueDType* m_queueIndexp = nullptr;
     AstBasicDType* m_basicps[AstBasicDTypeKwd::_ENUM_MAX];
     //
-    typedef std::map<VBasicTypeKey, AstBasicDType*> DetailedMap;
+    using DetailedMap = std::map<VBasicTypeKey, AstBasicDType*>;
     DetailedMap m_detailedMap;
 
 public:

src/V3Broken.cpp

@@ -41,7 +41,7 @@ class BrokenTable VL_NOT_FINAL : public AstNVisitor {
 private:
     // MEMBERS
     //   For each node, we keep if it exists or not.
-    typedef std::unordered_map<const AstNode*, int> NodeMap;  // Performance matters (when --debug)
+    using NodeMap = std::unordered_map<const AstNode*, int>;  // Performance matters (when --debug)
     static NodeMap s_nodes;  // Set of all nodes that exist
     // BITMASK
     enum { FLAG_ALLOCATED = 0x01 };  // new() and not delete()ed

src/V3CUse.cpp

@@ -40,7 +40,7 @@ class CUseState final {
 private:
     // MEMBERS
     AstNodeModule* m_modInsertp;  // Current module to insert AstCUse under
-    typedef std::pair<VUseType, string> UseString;
+    using UseString = std::pair<VUseType, std::string>;
     std::map<const UseString, AstCUse*> m_didUse;  // What we already used
 
     // NODE STATE

src/V3Combine.cpp

@@ -67,7 +67,7 @@ class CombCallVisitor final : CombBaseVisitor {
     // Find all CCALLS of each CFUNC, so that we can later rename them
 private:
     // NODE STATE
-    typedef std::multimap<AstCFunc*, AstCCall*> CallMmap;
+    using CallMmap = std::multimap<AstCFunc*, AstCCall*>;
     CallMmap m_callMmap;  // Associative array of {function}{call}
     // METHODS
 public:

src/V3Config.cpp

@@ -33,7 +33,7 @@
 // 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 {
-    typedef std::map<const string, T> Map;
+    using Map = std::map<const std::string, T>;
 
     Map m_mapWildcard;  // Wildcard strings to entities
     Map m_mapResolved;  // Resolved strings to converged entities
@@ -111,7 +111,7 @@ public:
     }
 };
 
-typedef V3ConfigWildcardResolver<V3ConfigVar> V3ConfigVarResolver;
+using V3ConfigVarResolver = V3ConfigWildcardResolver<V3ConfigVar>;
 
 //######################################################################
 // Function or task: Have variables and properties
@@ -148,7 +148,7 @@ public:
     }
 };
 
-typedef V3ConfigWildcardResolver<V3ConfigFTask> V3ConfigFTaskResolver;
+using V3ConfigFTaskResolver = V3ConfigWildcardResolver<V3ConfigFTask>;
 
 //######################################################################
 // Modules have tasks, variables, named blocks and properties
@@ -212,7 +212,7 @@ public:
     }
 };
 
-typedef V3ConfigWildcardResolver<V3ConfigModule> V3ConfigModuleResolver;
+using V3ConfigModuleResolver = V3ConfigWildcardResolver<V3ConfigModule>;
 
 //######################################################################
 // Files have:
@@ -246,14 +246,14 @@ std::ostream& operator<<(std::ostream& os, const V3ConfigIgnoresLine& rhs) {
 
 // Some attributes are attached to entities of the occur on a fileline
 // and multiple attributes can be attached to a line
-typedef std::bitset<AstPragmaType::ENUM_SIZE> V3ConfigLineAttribute;
+using V3ConfigLineAttribute = std::bitset<AstPragmaType::ENUM_SIZE>;
 
 // File entity
 class V3ConfigFile final {
-    typedef std::map<int, V3ConfigLineAttribute> LineAttrMap;  // Map line->bitset of attributes
-    typedef std::multiset<V3ConfigIgnoresLine> IgnLines;  // list of {line,code,on}
-    typedef std::pair<V3ErrorCode, string> WaiverSetting;  // Waive code if string matches
-    typedef std::vector<WaiverSetting> Waivers;  // List of {code,wildcard string}
+    using LineAttrMap = std::map<int, V3ConfigLineAttribute>;  // Map line->bitset of attributes
+    using IgnLines = std::multiset<V3ConfigIgnoresLine>;  // list of {line,code,on}
+    using WaiverSetting = std::pair<V3ErrorCode, std::string>;  // Waive code if string matches
+    using Waivers = std::vector<WaiverSetting>;  // List of {code,wildcard string}
 
     LineAttrMap m_lineAttrs;  // Atributes to line mapping
     IgnLines m_ignLines;  // Ignore line settings
@@ -338,7 +338,7 @@ public:
     }
 };
 
-typedef V3ConfigWildcardResolver<V3ConfigFile> V3ConfigFileResolver;
+using V3ConfigFileResolver = V3ConfigWildcardResolver<V3ConfigFile>;
 
 //######################################################################
 // Resolve modules and files in the design

src/V3Coverage.cpp

@@ -40,7 +40,7 @@
 class CoverageVisitor final : public AstNVisitor {
 private:
     // TYPES
-    typedef std::set<int> LinenoSet;
+    using LinenoSet = std::set<int>;
 
     struct ToggleEnt {
         string m_comment;  // Comment for coverage dump

src/V3Dead.cpp

@@ -79,7 +79,7 @@ private:
     AstUser1InUse m_inuser1;
 
     // TYPES
-    typedef std::multimap<AstVarScope*, AstNodeAssign*> AssignMap;
+    using AssignMap = std::multimap<AstVarScope*, AstNodeAssign*>;
 
     // STATE
     AstNodeModule* m_modp = nullptr;  // Current module

src/V3Delayed.cpp

@@ -94,7 +94,7 @@ private:
     bool m_inDly = false;  // True in delayed assignments
     bool m_inLoop = false;  // True in for loops
     bool m_inInitial = false;  // True in initial blocks
-    typedef std::map<const std::pair<AstNodeModule*, string>, AstVar*> VarMap;
+    using VarMap = std::map<const std::pair<AstNodeModule*, std::string>, AstVar*>;
     VarMap m_modVarMap;  // Table of new var names created under module
     VDouble0 m_statSharedSet;  // Statistic tracking
     std::unordered_map<const AstVarScope*, int> m_scopeVecMap;  // Next var number for each scope

src/V3Descope.cpp

@@ -42,7 +42,7 @@ private:
     AstUser1InUse m_inuser1;
 
     // TYPES
-    typedef std::multimap<string, AstCFunc*> FuncMmap;
+    using FuncMmap = std::multimap<std::string, AstCFunc*>;
 
     // STATE
     AstNodeModule* m_modp = nullptr;  // Current module

src/V3EmitC.cpp

@@ -41,8 +41,8 @@ constexpr int EMITC_NUM_CONSTW
 
 class EmitCStmts VL_NOT_FINAL : public EmitCBaseVisitor {
 private:
-    typedef std::vector<const AstVar*> VarVec;
-    typedef std::map<int, VarVec> VarSortMap;  // Map size class to VarVec
+    using VarVec = std::vector<const AstVar*>;
+    using VarSortMap = std::map<int, VarVec>;  // Map size class to VarVec
 
     bool m_suppressSemi;
     AstVarRef* m_wideTempRefp;  // Variable that _WW macros should be setting
@@ -2957,7 +2957,7 @@ void EmitCStmts::emitVarSort(const VarSortMap& vmap, VarVec* sortedp) {
     }
 
     // MacroTask mode.  Sort by MTask-affinity group first, size second.
-    typedef std::map<const MTaskIdSet, VarSortMap> MTaskVarSortMap;
+    using MTaskVarSortMap = std::map<const MTaskIdSet, VarSortMap>;
     MTaskVarSortMap m2v;
     for (VarSortMap::const_iterator it = vmap.begin(); it != vmap.end(); ++it) {
         int size_class = it->first;

src/V3EmitCSyms.cpp

@@ -71,11 +71,11 @@ class EmitCSyms final : EmitCBaseVisitor {
             , m_modp{modp}
             , m_scopep{scopep} {}
     };
-    typedef std::map<const string, ScopeData> ScopeNames;
-    typedef std::pair<AstScope*, AstNodeModule*> ScopeModPair;
-    typedef std::pair<AstNodeModule*, AstVar*> ModVarPair;
-    typedef std::vector<string> ScopeNameList;
-    typedef std::map<const string, ScopeNameList> ScopeNameHierarchy;
+    using ScopeNames = std::map<const std::string, ScopeData>;
+    using ScopeModPair = std::pair<AstScope*, AstNodeModule*>;
+    using ModVarPair = std::pair<AstNodeModule*, AstVar*>;
+    using ScopeNameList = std::vector<std::string>;
+    using ScopeNameHierarchy = std::map<const std::string, ScopeNameList>;
     struct CmpName {
         bool operator()(const ScopeModPair& lhsp, const ScopeModPair& rhsp) const {
             return lhsp.first->name() < rhsp.first->name();
@@ -401,7 +401,7 @@ void EmitCSyms::emitSymHdr() {
             AstCFunc* funcp = itr.second.m_cfuncp;
             if (funcp->dpiExport()) {
                 string cbtype = protect(v3Global.opt.prefix() + "__Vcb_" + funcp->cname() + "_t");
-                types["typedef void (*" + cbtype + ") (" + cFuncArgs(funcp) + ");\n"] = 1;
+                types["using " + cbtype + " = void (*) (" + cFuncArgs(funcp) + ");\n"] = 1;
             }
         }
         for (const auto& i : types) puts(i.first);

src/V3Error.h

@@ -226,8 +226,8 @@ inline std::ostream& operator<<(std::ostream& os, const V3ErrorCode& rhs) {
 class V3Error final {
     // Base class for any object that wants debugging and error reporting
 
-    typedef std::set<string> MessagesSet;
-    typedef void (*ErrorExitCb)(void);
+    using MessagesSet = std::set<std::string>;
+    using ErrorExitCb = void (*)(void);
 
 private:
     static bool s_describedWarnings;  // Told user how to disable warns

src/V3File.cpp

@@ -328,7 +328,7 @@ void V3File::createMakeDir() {
 // VInFilterImp
 
 class VInFilterImp final {
-    typedef VInFilter::StrList StrList;
+    using StrList = VInFilter::StrList;
 
     std::map<const std::string, std::string> m_contentsMap;  // Cache of file contents
     bool m_readEof = false;  // Received EOF on read

src/V3File.h

@@ -79,7 +79,7 @@ class VInFilterImp;
 class VInFilter final {
 public:
     // TYPES
-    typedef std::list<string> StrList;
+    using StrList = std::list<std::string>;
 
 private:
     VInFilterImp* m_impp;

src/V3Gate.cpp

@@ -37,7 +37,7 @@
 #include <map>
 #include <unordered_set>
 
-typedef std::list<AstNodeVarRef*> GateVarRefList;
+using GateVarRefList = std::list<AstNodeVarRef*>;
 
 constexpr int GATE_DEDUP_MAX_DEPTH = 20;
 

src/V3Graph.h

@@ -37,7 +37,7 @@ class OrderLogicVertex;
 // Most graph algorithms accept an arbitrary function that returns
 // True for those edges we should honor.
 
-typedef bool (*V3EdgeFuncP)(const V3GraphEdge* edgep);
+using V3EdgeFuncP = bool (*)(const V3GraphEdge* edgep);
 
 //=============================================================================
 // When the Graph represents a directional acyclical graph (DAG), following

src/V3GraphAcyc.cpp

@@ -56,7 +56,7 @@ public:
 class GraphAcycEdge final : public V3GraphEdge {
     // userp() is always used to point to the head original graph edge
 private:
-    typedef std::list<V3GraphEdge*> OrigEdgeList;  // List of orig edges, see also GraphAcyc's decl
+    using OrigEdgeList = std::list<V3GraphEdge*>;  // List of orig edges, see also GraphAcyc's decl
     V3GraphEdge* origEdgep() const {
         OrigEdgeList* oEListp = static_cast<OrigEdgeList*>(userp());
         if (!oEListp) v3fatalSrc("No original edge associated with acyc edge " << this);
@@ -89,8 +89,8 @@ struct GraphAcycEdgeCmp {
 // CLASSES
 class GraphAcyc final {
 private:
-    typedef std::list<V3GraphEdge*>
-        OrigEdgeList;  // List of orig edges, see also GraphAcycEdge's decl
+    using OrigEdgeList
+        = std::list<V3GraphEdge*>;  // List of orig edges, see also GraphAcycEdge's decl
     // GRAPH USERS
     //  origGraph
     //    GraphVertex::user()   GraphAycVerted* New graph node

src/V3GraphDfa.cpp

@@ -58,8 +58,8 @@ class GraphNfaToDfa final : GraphAlg<> {
     // Edges from DFA to DFA indicate a completed input transition
 private:
     // TYPES
-    typedef std::deque<DfaVertex*> DfaStates;
-    typedef std::multimap<vluint64_t, DfaVertex*> HashMap;
+    using DfaStates = std::deque<DfaVertex*>;
+    using HashMap = std::multimap<vluint64_t, DfaVertex*>;
 
     // MEMBERS
     uint32_t m_step;  // Processing step, so we can avoid clearUser all the time

src/V3GraphDfa.h

@@ -108,7 +108,7 @@ public:
 //============================================================================
 /// Abstract type indicating a specific "input" to the NFA
 /// DFA assumes each .toInt() is unique
-typedef VNUser DfaInput;
+using DfaInput = VNUser;
 
 //============================================================================
 // Edge types

src/V3GraphStream.h

@@ -80,7 +80,7 @@ private:
         VL_UNCOPYABLE(VxHolderCmp);
     };
 
-    typedef std::set<VxHolder, VxHolderCmp&> ReadyVertices;
+    using ReadyVertices = std::set<VxHolder, VxHolderCmp&>;
 
     // MEMBERS
     VxHolderCmp m_vxHolderCmp;  // Vertext comparison functor
@@ -227,6 +227,6 @@ private:
 // GraphStreamUnordered is GraphStream using a plain pointer compare to
 // break ties in the graph order. This WILL return nodes in
 // nondeterministic order.
-typedef GraphStream<std::less<const V3GraphVertex*>> GraphStreamUnordered;
+using GraphStreamUnordered = GraphStream<std::less<const V3GraphVertex*>>;
 
 #endif  // Guard

src/V3Hashed.h

@@ -50,8 +50,8 @@ class V3Hashed final : public VHashedBase {
 
     // TYPES
 public:
-    typedef std::multimap<V3Hash, AstNode*> HashMmap;
-    typedef HashMmap::iterator iterator;
+    using HashMmap = std::multimap<V3Hash, AstNode*>;
+    using iterator = HashMmap::iterator;
 
 private:
     // MEMBERS

src/V3HierBlock.cpp

@@ -240,7 +240,7 @@ class HierBlockUsageCollectVisitor final : public AstNVisitor {
     AstUser1InUse m_inuser1;
 
     // STATE
-    typedef std::unordered_set<const AstModule*> ModuleSet;
+    using ModuleSet = std::unordered_set<const AstModule*>;
     V3HierBlockPlan* const m_planp;
     AstModule* m_modp = nullptr;  // The current module
     AstModule* m_hierBlockp = nullptr;  // The nearest parent module that is a hierarchical block
@@ -355,8 +355,8 @@ void V3HierBlockPlan::createPlan(AstNetlist* nodep) {
 }
 
 V3HierBlockPlan::HierVector V3HierBlockPlan::hierBlocksSorted() const {
-    typedef std::unordered_map<const V3HierBlock*, std::unordered_set<const V3HierBlock*>>
-        ChildrenMap;
+    using ChildrenMap
+        = std::unordered_map<const V3HierBlock*, std::unordered_set<const V3HierBlock*>>;
     ChildrenMap childrenOfHierBlock;
 
     HierVector sorted;

src/V3HierBlock.h

@@ -40,13 +40,13 @@ class AstVar;
 
 class V3HierBlock final {
 public:
-    typedef std::vector<AstVar*> GParams;
-    typedef std::unordered_set<V3HierBlock*> HierBlockSet;
+    using GParams = std::vector<AstVar*>;
+    using HierBlockSet = std::unordered_set<V3HierBlock*>;
 
 private:
     // TYPES
     // Parameter name, stringified value
-    typedef std::vector<std::pair<string, string>> StrGParams;
+    using StrGParams = std::vector<std::pair<std::string, std::string>>;
 
     // MEMBERS
     const AstNodeModule* m_modp;  // Hierarchical block module
@@ -96,16 +96,16 @@ public:
 
 // Holds relashonship between AstNodeModule and V3HierBlock
 class V3HierBlockPlan final {
-    typedef std::unordered_map<const AstNodeModule*, V3HierBlock*> HierMap;
+    using HierMap = std::unordered_map<const AstNodeModule*, V3HierBlock*>;
     HierMap m_blocks;
 
     V3HierBlockPlan() = default;
     VL_UNCOPYABLE(V3HierBlockPlan);
 
 public:
-    typedef HierMap::iterator iterator;
-    typedef HierMap::const_iterator const_iterator;
-    typedef std::vector<const V3HierBlock*> HierVector;
+    using iterator = HierMap::iterator;
+    using const_iterator = HierMap::const_iterator;
+    using HierVector = std::vector<const V3HierBlock*>;
     VL_DEBUG_FUNC;  // Declare debug()
 
     bool isHierBlock(const AstNodeModule* modp) const;

src/V3Inline.cpp

@@ -69,12 +69,12 @@ private:
     AstNodeModule* m_modp = nullptr;  // Current module
     VDouble0 m_statUnsup;  // Statistic tracking
 
-    typedef std::vector<AstNodeModule*> ModVec;
+    using ModVec = std::vector<AstNodeModule*>;
     ModVec m_allMods;  // All modules, in top-down order.
 
     // Within the context of a given module, LocalInstanceMap maps
     // from child modules to the count of each child's local instantiations.
-    typedef std::unordered_map<AstNodeModule*, int> LocalInstanceMap;
+    using LocalInstanceMap = std::unordered_map<AstNodeModule*, int>;
 
     // We keep a LocalInstanceMap for each module in the design
     std::unordered_map<AstNodeModule*, LocalInstanceMap> m_instances;

src/V3LanguageWords.h

@@ -27,7 +27,7 @@
 class V3LanguageWords final {
     // List of common reserved keywords
 private:
-    typedef std::map<const string, string> KeywordMap;
+    using KeywordMap = std::map<const string, std::string>;
     struct Singleton {
         KeywordMap s_kwdMap;  // List of keywords, and what language applies
         Singleton() { init(); }
@@ -36,7 +36,7 @@ private:
     };
 
 public:
-    typedef KeywordMap::const_iterator const_iterator;
+    using const_iterator = KeywordMap::const_iterator;
     // METHODS
     static const_iterator begin() { return s().s_kwdMap.begin(); }
     static const_iterator end() { return s().s_kwdMap.end(); }

src/V3Life.cpp

@@ -123,7 +123,7 @@ class LifeBlock final {
 
     // LIFE MAP
     //  For each basic block, we'll make a new map of what variables that if/else is changing
-    typedef std::unordered_map<AstVarScope*, LifeVarEntry> LifeMap;
+    using LifeMap = std::unordered_map<AstVarScope*, LifeVarEntry>;
     LifeMap m_map;  // Current active lifetime map for current scope
     LifeBlock* m_aboveLifep;  // Upper life, or nullptr
     LifeState* m_statep;  // Current global state
@@ -278,7 +278,7 @@ private:
 
     // LIFE MAP
     //  For each basic block, we'll make a new map of what variables that if/else is changing
-    typedef std::unordered_map<AstVarScope*, LifeVarEntry> LifeMap;
+    using LifeMap = std::unordered_map<AstVarScope*, LifeVarEntry>;
     // cppcheck-suppress memleak  // cppcheck bug - it is deleted
     LifeBlock* m_lifep;  // Current active lifetime map for current scope
 

src/V3LifePost.cpp

@@ -145,7 +145,7 @@ private:
 
     // Map each varscope to one or more locations where it's accessed.
     // These maps will not include any ASSIGNPOST accesses:
-    typedef std::unordered_map<const AstVarScope*, std::set<LifeLocation>> LocMap;
+    using LocMap = std::unordered_map<const AstVarScope*, std::set<LifeLocation>>;
     LocMap m_reads;  // VarScope read locations
     LocMap m_writes;  // VarScope write locations
 

src/V3LinkDot.cpp

@@ -140,8 +140,8 @@ public:
 
 private:
     // TYPES
-    typedef std::unordered_map<VSymEnt*, VSymEnt*> ScopeAliasMap;
-    typedef std::vector<std::pair<AstIface*, VSymEnt*>> IfaceModSyms;
+    using ScopeAliasMap = std::unordered_map<VSymEnt*, VSymEnt*>;
+    using IfaceModSyms = std::vector<std::pair<AstIface*, VSymEnt*>>;
 
     static LinkDotState* s_errorThisp;  // Last self, for error reporting only
 

src/V3LinkLevel.cpp

@@ -171,7 +171,7 @@ void V3LinkLevel::wrapTopCell(AstNetlist* rootp) {
     UASSERT_OBJ(newmodp && newmodp->isTop(), rootp, "No TOP module found to insert under");
 
     // Find all duplicate signal names (if multitop)
-    typedef std::unordered_set<std::string> NameSet;
+    using NameSet = std::unordered_set<std::string>;
     NameSet ioNames;
     NameSet dupNames;
     // For all modules, skipping over new top

src/V3LinkLevel.h

@@ -27,7 +27,7 @@
 
 class V3LinkLevel final {
 private:
-    typedef std::vector<AstNodeModule*> ModVec;
+    using ModVec = std::vector<AstNodeModule*>;
 
     static void timescaling(const ModVec& mods);
     static void wrapTopCell(AstNetlist* rootp);

src/V3LinkParse.cpp

@@ -44,7 +44,7 @@ private:
     AstUser2InUse m_inuser2;
 
     // TYPES
-    typedef std::map<const std::pair<void*, string>, AstTypedef*> ImplTypedefMap;
+    using ImplTypedefMap = std::map<const std::pair<void*, std::string>, AstTypedef*>;
 
     // STATE
     AstVar* m_varp = nullptr;  // Variable we're under

src/V3Number.h

@@ -312,8 +312,8 @@ public:
     // STATICS
     static int log2b(uint32_t num);
 
-    typedef V3Number& (*UniopFuncp)(V3Number&);
-    typedef V3Number& (*BiopFuncp)(V3Number&, V3Number&);
+    using UniopFuncp = V3Number& (*)(V3Number&);
+    using BiopFuncp = V3Number& (*)(V3Number&, V3Number&);
 
     // MATH
     // "this" is the output, as we need the output width before some computations

src/V3Options.cpp

@@ -54,7 +54,7 @@
 class V3OptionsImp final {
 public:
     // TYPES
-    typedef std::map<const string, std::set<string>> DirMap;  // Directory listing
+    using DirMap = std::map<const string, std::set<std::string>>;  // Directory listing
 
     // STATE
     std::list<string> m_allArgs;  // List of every argument encountered

src/V3Options.h

@@ -152,8 +152,8 @@ inline bool operator==(const TraceFormat& lhs, const TraceFormat& rhs) {
 inline bool operator==(const TraceFormat& lhs, TraceFormat::en rhs) { return lhs.m_e == rhs; }
 inline bool operator==(TraceFormat::en lhs, const TraceFormat& rhs) { return lhs == rhs.m_e; }
 
-typedef std::vector<string> V3StringList;
-typedef std::set<string> V3StringSet;
+using V3StringList = std::vector<std::string>;
+using V3StringSet = std::set<std::string>;
 
 //######################################################################
 
@@ -161,7 +161,7 @@ typedef std::set<string> V3StringSet;
 class V3HierarchicalBlockOption final {
 public:
     // key:parameter name, value:value (as string)
-    typedef std::map<const string, string> ParamStrMap;
+    using ParamStrMap = std::map<const std::string, std::string>;
 
 private:
     string m_origName;  // module name
@@ -178,7 +178,7 @@ public:
     const ParamStrMap params() const { return m_parameters; }
 };
 
-typedef std::map<const string, V3HierarchicalBlockOption> V3HierBlockOptSet;
+using V3HierBlockOptSet = std::map<const std::string, V3HierarchicalBlockOption>;
 
 //######################################################################
 // V3Options - Command line options
@@ -187,7 +187,7 @@ class V3Options final {
 public:
 private:
     // TYPES
-    typedef std::map<const string, int> DebugSrcMap;
+    using DebugSrcMap = std::map<const std::string, int>;
 
     // MEMBERS (general options)
     V3OptionsImp* m_impp;  // Slow hidden options

src/V3Order.cpp

@@ -136,8 +136,8 @@ private:
     const AstSenTree* m_domainp;  // Domain all vertices belong to
     const AstScope* m_scopep;  // Scope all vertices belong to
 
-    typedef std::pair<const AstSenTree*, const AstScope*> DomScopeKey;
-    typedef std::map<DomScopeKey, OrderMoveDomScope*> DomScopeMap;
+    using DomScopeKey = std::pair<const AstSenTree*, const AstScope*>;
+    using DomScopeMap = std::map<DomScopeKey, OrderMoveDomScope*>;
     static DomScopeMap s_dsMap;  // Structure registered for each dom/scope pairing
 
 public:
@@ -421,8 +421,8 @@ template <class T_MoveVertex> class ProcessMoveBuildGraph {
     //   works the same way for both cases.
 
     // TYPES
-    typedef std::pair<const V3GraphVertex*, const AstSenTree*> VxDomPair;
-    typedef std::unordered_map<const OrderLogicVertex*, T_MoveVertex*> Logic2Move;
+    using VxDomPair = std::pair<const V3GraphVertex*, const AstSenTree*>;
+    using Logic2Move = std::unordered_map<const OrderLogicVertex*, T_MoveVertex*>;
 
 public:
     class MoveVertexMaker VL_NOT_FINAL {
@@ -729,7 +729,7 @@ private:
 
     void process();
     void processCircular();
-    typedef std::deque<OrderEitherVertex*> VertexVec;
+    using VertexVec = std::deque<OrderEitherVertex*>;
     void processInputs();
     void processInputsInIterate(OrderEitherVertex* vertexp, VertexVec& todoVec);
     void processInputsOutIterate(OrderEitherVertex* vertexp, VertexVec& todoVec);

src/V3Param.cpp

@@ -67,11 +67,11 @@
 // Hierarchical block and parameter db (modules without parameter is also handled)
 
 class ParameterizedHierBlocks final {
-    typedef std::multimap<string, const V3HierarchicalBlockOption*> HierBlockOptsByOrigName;
-    typedef HierBlockOptsByOrigName::const_iterator HierMapIt;
-    typedef std::map<const string, AstNodeModule*> HierBlockModMap;
-    typedef std::map<const string, std::unique_ptr<AstConst>> ParamConstMap;
-    typedef std::map<const string, AstVar*> GParamsMap;  // key:parameter name value:parameter
+    using HierBlockOptsByOrigName = std::multimap<std::string, const V3HierarchicalBlockOption*>;
+    using HierMapIt = HierBlockOptsByOrigName::const_iterator;
+    using HierBlockModMap = std::map<const std::string, AstNodeModule*>;
+    using ParamConstMap = std::map<const std::string, std::unique_ptr<AstConst>>;
+    using GParamsMap = std::map<const std::string, AstVar*>;  // key:parameter name value:parameter
 
     // MEMBERS
     // key:Original module name, value:HiearchyBlockOption*
@@ -232,10 +232,10 @@ class ParamProcessor final {
 
     // TYPES
     // Note may have duplicate entries
-    typedef std::deque<std::pair<AstIfaceRefDType*, AstIfaceRefDType*>> IfaceRefRefs;
+    using IfaceRefRefs = std::deque<std::pair<AstIfaceRefDType*, AstIfaceRefDType*>>;
 
     // STATE
-    typedef std::unordered_map<const AstNode*, AstNode*> CloneMap;
+    using CloneMap = std::unordered_map<const AstNode*, AstNode*>;
     struct ModInfo {
         AstNodeModule* m_modp;  // Module with specified name
         CloneMap m_cloneMap;  // Map of old-varp -> new cloned varp
@@ -252,7 +252,7 @@ class ParamProcessor final {
     // Generated modules by this visitor is not included
     V3StringSet m_allModuleNames;
 
-    typedef std::pair<int, string> ValueMapValue;
+    using ValueMapValue = std::pair<int, std::string>;
     std::map<const V3Hash, ValueMapValue> m_valueMap;  // Hash of node hash to (param value, name)
     int m_nextValue = 1;  // Next value to use in m_valueMap
 
@@ -261,7 +261,7 @@ class ParamProcessor final {
     // Database to get protect-lib wrapper that matches parameters in hierarchical Verilation
     ParameterizedHierBlocks m_hierBlocks;
     // Default parameter values key:parameter name, value:default value (can be nullptr)
-    typedef std::map<string, AstConst*> DefaultValueMap;
+    using DefaultValueMap = std::map<std::string, AstConst*>;
     // Default parameter values of hierarchical blocks
     std::map<AstNodeModule*, DefaultValueMap> m_defaultParameterValues;
 

src/V3ParseSym.h

@@ -32,7 +32,7 @@
 
 class V3ParseSym final {
     // TYPES
-    typedef std::vector<VSymEnt*> SymStack;
+    using SymStack = std::vector<VSymEnt*>;
 
 private:
     // MEMBERS

src/V3Partition.cpp

@@ -247,7 +247,7 @@ private:
     // MEMBERS
     V3Graph m_graph;  // A graph
     V3GraphVertex* m_vx[50];  // All vertices within the graph
-    typedef std::unordered_map<V3GraphVertex*, uint32_t> CpMap;
+    using CpMap = std::unordered_map<V3GraphVertex*, uint32_t>;
     CpMap m_cp;  // Vertex-to-CP map
     CpMap m_seen;  // Set of vertices we've seen
 
@@ -353,7 +353,7 @@ public:
 class LogicMTask final : public AbstractLogicMTask {
 public:
     // TYPES
-    typedef std::list<MTaskMoveVertex*> VxList;
+    using VxList = std::list<MTaskMoveVertex*>;
 
     struct CmpLogicMTask {
         bool operator()(const LogicMTask* ap, const LogicMTask* bp) const {
@@ -442,7 +442,7 @@ private:
     // our edge with them. The SortByValueMap supports iterating over
     // relatives in longest-to-shortest CP order.  We rely on this ordering
     // in more than one place.
-    typedef SortByValueMap<LogicMTask*, uint32_t, CmpLogicMTask> EdgeSet;
+    using EdgeSet = SortByValueMap<LogicMTask*, uint32_t, CmpLogicMTask>;
     std::array<EdgeSet, GraphWay::NUM_WAYS> m_edges;
 
 public:
@@ -1035,9 +1035,9 @@ private:
     // TODO: might get a little more speed by making this a
     // std::unordered_set and defining hash and equal_to functors for the
     // SiblingMC:
-    typedef std::set<SiblingMC> SibSet;
-    typedef std::unordered_set<const SiblingMC*> SibpSet;
-    typedef std::unordered_map<const LogicMTask*, SibpSet> MTask2Sibs;
+    using SibSet = std::set<SiblingMC>;
+    using SibpSet = std::unordered_set<const SiblingMC*>;
+    using MTask2Sibs = std::unordered_map<const LogicMTask*, SibpSet>;
 
     // New CP information for mtaskp reflecting an upcoming merge
     struct NewCp {
@@ -1756,10 +1756,10 @@ private:
 class PartFixDataHazards final {
 private:
     // TYPES
-    typedef std::set<LogicMTask*, MTaskIdLessThan> LogicMTaskSet;
-    typedef std::map<uint32_t /*rank*/, LogicMTaskSet> TasksByRank;
-    typedef std::set<const OrderVarStdVertex*, OrderByPtrId&> OvvSet;
-    typedef std::unordered_map<const OrderLogicVertex*, LogicMTask*> Olv2MTaskMap;
+    using LogicMTaskSet = std::set<LogicMTask*, MTaskIdLessThan>;
+    using TasksByRank = std::map<uint32_t /*rank*/, LogicMTaskSet>;
+    using OvvSet = std::set<const OrderVarStdVertex*, OrderByPtrId&>;
+    using Olv2MTaskMap = std::unordered_map<const OrderLogicVertex*, LogicMTask*>;
 
     // MEMBERS
     V3Graph* m_mtasksp;  // Mtask graph
@@ -2031,11 +2031,11 @@ private:
     uint32_t m_sandbagNumerator;  // Numerator padding for est runtime
     uint32_t m_sandbagDenom;  // Denomerator padding for est runtime
 
-    typedef std::unordered_map<const ExecMTask*, MTaskState> MTaskStateMap;
+    using MTaskStateMap = std::unordered_map<const ExecMTask*, MTaskState>;
     MTaskStateMap m_mtaskState;  // State for each mtask.
 
     MTaskCmp m_mtaskCmp;  // Comparison functor
-    typedef std::set<ExecMTask*, MTaskCmp&> ReadyMTasks;
+    using ReadyMTasks = std::set<ExecMTask*, MTaskCmp&>;
     ReadyMTasks m_ready;  // MTasks ready to be assigned next; all their
     //                    // dependencies are already assigned.
 
@@ -2449,7 +2449,7 @@ void V3Partition::go(V3Graph* mtasksp) {
     // order though, otherwise we break CmpLogicMTask for still-existing
     // EdgeSet's that haven't destructed yet.
     {
-        typedef std::set<LogicMTask*, LogicMTask::CmpLogicMTask> SortedMTaskSet;
+        using SortedMTaskSet = std::set<LogicMTask*, LogicMTask::CmpLogicMTask>;
         SortedMTaskSet sorted;
         for (V3GraphVertex* itp = mtasksp->verticesBeginp(); itp; itp = itp->verticesNextp()) {
             LogicMTask* mtaskp = dynamic_cast<LogicMTask*>(itp);

src/V3Partition.h

@@ -26,7 +26,7 @@
 #include <list>
 
 class LogicMTask;
-typedef std::unordered_map<const MTaskMoveVertex*, LogicMTask*> Vx2MTaskMap;
+using Vx2MTaskMap = std::unordered_map<const MTaskMoveVertex*, LogicMTask*>;
 
 //*************************************************************************
 /// V3Partition takes the fine-grained logic graph from V3Order and

src/V3PartitionGraph.h

@@ -40,7 +40,7 @@ public:
 class AbstractLogicMTask VL_NOT_FINAL : public AbstractMTask {
 public:
     // TYPES
-    typedef std::list<MTaskMoveVertex*> VxList;
+    using VxList = std::list<MTaskMoveVertex*>;
     // CONSTRUCTORS
     AbstractLogicMTask(V3Graph* graphp)
         : AbstractMTask{graphp} {}

src/V3PreProc.cpp

@@ -108,8 +108,8 @@ public:
 class V3PreProcImp final : public V3PreProc {
 public:
     // TYPES
-    typedef std::map<const string, VDefine> DefinesMap;
-    typedef VInFilter::StrList StrList;
+    using DefinesMap = std::map<const std::string, VDefine>;
+    using StrList = VInFilter::StrList;
 
     // debug() -> see V3PreShellImp::debug; use --debugi-V3PreShell
 

src/V3Randomize.cpp

@@ -39,8 +39,8 @@ private:
     //  AstClass::user1()       -> bool.  Set true to indicate needs randomize processing
     AstUser1InUse m_inuser1;
 
-    typedef std::unordered_set<AstClass*> DerivedSet;
-    typedef std::unordered_map<AstClass*, DerivedSet> BaseToDerivedMap;
+    using DerivedSet = std::unordered_set<AstClass*>;
+    using BaseToDerivedMap = std::unordered_map<AstClass*, DerivedSet>;
 
     BaseToDerivedMap m_baseToDerivedMap;  // Mapping from base classes to classes that extend them
 

src/V3Scope.cpp

@@ -46,7 +46,7 @@ private:
 
     // TYPES
     // These cannot be unordered unless make a specialized hashing pair (gcc-8)
-    typedef std::map<std::pair<AstVar*, AstScope*>, AstVarScope*> VarScopeMap;
+    using VarScopeMap = std::map<std::pair<AstVar*, AstScope*>, AstVarScope*>;
 
     // STATE, inside processing a single module
     AstNodeModule* m_modp = nullptr;  // Current module

src/V3Scoreboard.h

@@ -44,8 +44,8 @@ template <typename T_Key, typename T_Value, class T_KeyCompare = std::less<T_Key
 class SortByValueMap final {
     // TYPES
 private:
-    typedef std::set<T_Key, T_KeyCompare> KeySet;
-    typedef std::map<T_Value, KeySet> Val2Keys;
+    using KeySet = std::set<T_Key, T_KeyCompare>;
+    using Val2Keys = std::map<T_Value, KeySet>;
 
     // MEMBERS
     std::unordered_map<T_Key, T_Value> m_keys;  // Map each key to its value. Not sorted.
@@ -58,11 +58,11 @@ public:
     class const_iterator VL_NOT_FINAL {
         // TYPES
     public:
-        typedef const_iterator value_type;
-        typedef const_iterator reference;  // See comment on operator*()
-        typedef void pointer;
-        typedef std::ptrdiff_t difference_type;
-        typedef std::bidirectional_iterator_tag iterator_category;
+        using value_type = const_iterator;
+        using reference = const_iterator;  // See comment on operator*()
+        using pointer = void;
+        using difference_type = std::ptrdiff_t;
+        using iterator_category = std::bidirectional_iterator_tag;
 
     protected:
         friend class SortByValueMap;
@@ -195,8 +195,8 @@ public:
     class iterator final : public const_iterator {
     public:
         // TYPES
-        typedef iterator value_type;
-        typedef iterator reference;
+        using value_type = iterator;
+        using reference = iterator;
         // pointer, difference_type, and iterator_category inherit from
         // const_iterator
 
@@ -222,8 +222,8 @@ public:
         }
     };
 
-    typedef std::reverse_iterator<iterator> reverse_iterator;
-    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
     // METHODS
 private:
@@ -359,8 +359,8 @@ private:
             return cmp.operator()(*ap, *bp);
         }
     };
-    typedef SortByValueMap<const T_Elem*, T_Score, CmpElems> SortedMap;
-    typedef T_Score (*UserScoreFnp)(const T_Elem*);
+    using SortedMap = SortByValueMap<const T_Elem*, T_Score, CmpElems>;
+    using UserScoreFnp = T_Score (*)(const T_Elem*);
 
     // MEMBERS
     std::unordered_set<const T_Elem*> m_unknown;  // Elements with unknown scores

src/V3SenTree.h

@@ -48,7 +48,7 @@ private:
     };
 
     // MEMBERS
-    typedef std::unordered_set<AstSenTree*, HashSenTree, EqSenTree> Set;
+    using Set = std::unordered_set<AstSenTree*, HashSenTree, EqSenTree>;
     Set m_trees;  // Set of sensitive blocks, for folding.
 
 public:

src/V3Simulate.h

@@ -60,8 +60,8 @@ public:
     ~SimStackNode() = default;
 };
 
-typedef std::deque<AstConst*> ConstDeque;
-typedef std::unordered_map<const AstNodeDType*, ConstDeque> ConstPile;
+using ConstDeque = std::deque<AstConst*>;
+using ConstPile = std::unordered_map<const AstNodeDType*, ConstDeque>;
 
 class SimulateVisitor VL_NOT_FINAL : public AstNVisitor {
     // Simulate a node tree, returning value of variables

src/V3Split.cpp

@@ -615,8 +615,8 @@ private:
     VL_UNCOPYABLE(ReorderVisitor);
 };
 
-typedef std::unordered_set<uint32_t> ColorSet;
-typedef std::vector<AstAlways*> AlwaysVec;
+using ColorSet = std::unordered_set<uint32_t>;
+using AlwaysVec = std::vector<AstAlways*>;
 
 class IfColorVisitor final : public AstNVisitor {
     // MEMBERS
@@ -752,7 +752,7 @@ protected:
 
     virtual void visit(AstNodeIf* nodep) override {
         const ColorSet& colors = m_ifColorp->colors(nodep);
-        typedef std::unordered_map<uint32_t, AstNodeIf*> CloneMap;
+        using CloneMap = std::unordered_map<uint32_t, AstNodeIf*>;
         CloneMap clones;
 
         for (unsigned int color : colors) {

src/V3SplitVar.cpp

@@ -285,9 +285,9 @@ public:
 
 class UnpackRefMap final {
 public:
-    typedef std::map<AstVar*, std::set<UnpackRef>, AstNodeComparator> MapType;
-    typedef MapType::iterator MapIt;
-    typedef MapType::value_type::second_type::iterator SetIt;
+    using MapType = std::map<AstVar*, std::set<UnpackRef>, AstNodeComparator>;
+    using MapIt = MapType::iterator;
+    using SetIt = MapType::value_type::second_type::iterator;
 
 private:
     MapType m_map;
@@ -379,10 +379,10 @@ public:
     }
 };
 
-typedef std::map<AstNodeModule*, RefsInModule, AstNodeComparator> SplitVarRefsMap;
+using SplitVarRefsMap = std::map<AstNodeModule*, RefsInModule, AstNodeComparator>;
 
 class SplitUnpackedVarVisitor final : public AstNVisitor, public SplitVarImpl {
-    typedef std::set<AstVar*, AstNodeComparator> VarSet;
+    using VarSet = std::set<AstVar*, AstNodeComparator>;
     VarSet m_foundTargetVar;
     UnpackRefMap m_refs;
     AstNodeModule* m_modp = nullptr;
@@ -879,8 +879,8 @@ class PackedVarRef final {
     }
 
 public:
-    typedef std::vector<PackedVarRefEntry>::iterator iterator;
-    typedef std::vector<PackedVarRefEntry>::const_iterator const_iterator;
+    using iterator = std::vector<PackedVarRefEntry>::iterator;
+    using const_iterator = std::vector<PackedVarRefEntry>::const_iterator;
     std::vector<PackedVarRefEntry>& lhs() {
         UASSERT(m_dedupDone, "cannot read before dedup()");
         return m_lhs;

src/V3Stats.cpp

@@ -34,7 +34,7 @@ class StatsVisitor final : public AstNVisitor {
 private:
     // NODE STATE/TYPES
 
-    typedef std::map<const string, int> NameMap;  // Number of times a name appears
+    using NameMap = std::map<const std::string, int>;  // Number of times a name appears
 
     // STATE
     string m_stage;  // Name of the stage we are scanning

src/V3StatsReport.cpp

@@ -32,7 +32,7 @@
 
 class StatsReport final {
     // TYPES
-    typedef std::vector<V3Statistic> StatColl;
+    using StatColl = std::vector<V3Statistic>;
 
     // STATE
     std::ofstream& os;  ///< Output stream

src/V3String.h

@@ -193,7 +193,7 @@ class VSpellCheck final {
     static constexpr unsigned NUM_CANDIDATE_LIMIT = 10000;  // Avoid searching huge netlists
     static constexpr unsigned LENGTH_LIMIT = 100;  // Maximum string length to search
     // TYPES
-    typedef unsigned int EditDistance;
+    using EditDistance = unsigned int;
     // MEMBERS
     std::vector<std::string> m_candidates;  // Strings we try to match
 public:

src/V3SymTable.h

@@ -36,12 +36,12 @@ class VSymEnt;
 //######################################################################
 // Symbol table
 
-typedef std::unordered_set<const VSymEnt*> VSymConstMap;
+using VSymConstMap = std::unordered_set<const VSymEnt*>;
 
 class VSymEnt final {
     // Symbol table that can have a "superior" table for resolving upper references
     // MEMBERS
-    typedef std::multimap<string, VSymEnt*> IdNameMap;
+    using IdNameMap = std::multimap<std::string, VSymEnt*>;
     IdNameMap m_idNameMap;  // Hash of variables by name
     AstNode* m_nodep;  // Node that entry belongs to
     VSymEnt* m_fallbackp;  // Table "above" this one in name scope, for fallback resolution
@@ -60,7 +60,7 @@ class VSymEnt final {
     static constexpr int debug() { return 0; }  // NOT runtime, too hot of a function
 #endif
 public:
-    typedef IdNameMap::const_iterator const_iterator;
+    using const_iterator = IdNameMap::const_iterator;
     const_iterator begin() const { return m_idNameMap.begin(); }
     const_iterator end() const { return m_idNameMap.end(); }
 
@@ -280,7 +280,7 @@ public:
 class VSymGraph final {
     // Collection of symbol tables
     // TYPES
-    typedef std::vector<VSymEnt*> SymStack;
+    using SymStack = std::vector<VSymEnt*>;
 
     // MEMBERS
     VSymEnt* m_symRootp;  // Root symbol table

src/V3TSP.cpp

@@ -71,7 +71,7 @@ private:
 template <typename T_Key> class TspGraphTmpl : public V3Graph {
 public:
     // TYPES
-    typedef TspVertexTmpl<T_Key> Vertex;
+    using Vertex = TspVertexTmpl<T_Key>;
 
     // MEMBERS
     std::unordered_map<T_Key, Vertex*> m_vertices;  // T_Key to Vertex lookup map
@@ -151,7 +151,7 @@ public:
         std::unordered_set<Vertex*> visited_set;
 
         EdgeCmp cmp;
-        typedef std::set<V3GraphEdge*, EdgeCmp&> PendingEdgeSet;
+        using PendingEdgeSet = std::set<V3GraphEdge*, EdgeCmp&>;
         // This is the set of pending edges from visited to unvisited
         // nodes.
         PendingEdgeSet pendingEdges(cmp);
@@ -221,7 +221,7 @@ public:
 
         std::list<Vertex*> odds = keysToVertexList(oddKeys);
         std::unordered_set<Vertex*> unmatchedOdds;
-        typedef typename std::list<Vertex*>::iterator VertexListIt;
+        using VertexListIt = typename std::list<Vertex*>::iterator;
         for (VertexListIt it = odds.begin(); it != odds.end(); ++it) {
             outp->addVertex((*it)->key());
             unmatchedOdds.insert(*it);
@@ -246,7 +246,7 @@ public:
         // bidir edge will collide in the pendingEdges set here, but this
         // is OK, we'll ignore the direction on the edge anyway.
         EdgeCmp cmp;
-        typedef std::set<V3GraphEdge*, EdgeCmp&> PendingEdgeSet;
+        using PendingEdgeSet = std::set<V3GraphEdge*, EdgeCmp&>;
         PendingEdgeSet pendingEdges(cmp);
 
         for (VertexListIt it = odds.begin(); it != odds.end(); ++it) {
@@ -408,7 +408,7 @@ void V3TSP::tspSort(const V3TSP::StateVec& states, V3TSP::StateVec* resultp) {
     }
 
     // Build the initial graph from the starting state set.
-    typedef TspGraphTmpl<const TspStateBase*> Graph;
+    using Graph = TspGraphTmpl<const TspStateBase*>;
     Graph graph;
     for (const auto& state : states) graph.addVertex(state);
     for (V3TSP::StateVec::const_iterator it = states.begin(); it != states.end(); ++it) {
@@ -613,7 +613,7 @@ void V3TSP::selfTestStates() {
 }
 
 void V3TSP::selfTestString() {
-    typedef TspGraphTmpl<string> Graph;
+    using Graph = TspGraphTmpl<std::string>;
     Graph graph;
     graph.addVertex("0");
     graph.addVertex("1");

src/V3TSP.h

@@ -43,7 +43,7 @@ public:
     virtual ~TspStateBase() = default;
 };
 
-typedef std::vector<const TspStateBase*> StateVec;
+using StateVec = std::vector<const TspStateBase*>;
 
 // Given an unsorted set of TspState's, sort them to minimize
 // the transition cost for walking the sorted list.

src/V3Task.cpp

@@ -103,8 +103,8 @@ private:
     AstUser4InUse m_inuser4;
 
     // TYPES
-    typedef std::map<std::pair<AstScope*, AstVar*>, AstVarScope*> VarToScopeMap;
-    typedef std::unordered_map<const AstNodeFTask*, AstClass*> FuncToClassMap;
+    using VarToScopeMap = std::map<std::pair<AstScope*, AstVar*>, AstVarScope*>;
+    using FuncToClassMap = std::unordered_map<const AstNodeFTask*, AstClass*>;
     // MEMBERS
     VarToScopeMap m_varToScopeMap;  // Map for Var -> VarScope mappings
     FuncToClassMap m_funcToClassMap;  // Map for ctor func -> class
@@ -385,7 +385,7 @@ private:
         IM_AFTER,  // Pointing at last inserted stmt, insert after
         IM_WHILE_PRECOND  // Pointing to for loop, add to body end
     };
-    typedef std::map<const string, std::pair<AstNodeFTask*, string>> DpiNames;
+    using DpiNames = std::map<const string, std::pair<AstNodeFTask*, std::string>>;
 
     // STATE
     TaskStateVisitor* m_statep;  // Common state between visitors

src/V3Task.h

@@ -27,8 +27,8 @@
 
 //============================================================================
 
-typedef std::pair<AstVar*, AstArg*> V3TaskConnect;  // [port, pin-connects-to]
-typedef std::vector<V3TaskConnect> V3TaskConnects;  // [ [port, pin-connects-to] ... ]
+using V3TaskConnect = std::pair<AstVar*, AstArg*>;  // [port, pin-connects-to]
+using V3TaskConnects = std::vector<V3TaskConnect>;  // [ [port, pin-connects-to] ... ]
 
 //============================================================================
 

src/V3Trace.cpp

@@ -184,9 +184,9 @@ private:
     VDouble0 m_statUniqCodes;  // Statistic tracking
 
     // All activity numbers applying to a given trace
-    typedef std::set<uint32_t> ActCodeSet;
+    using ActCodeSet = std::set<uint32_t>;
     // For activity set, what traces apply
-    typedef std::multimap<ActCodeSet, TraceTraceVertex*> TraceVec;
+    using TraceVec = std::multimap<ActCodeSet, TraceTraceVertex*>;
 
     // METHODS
     VL_DEBUG_FUNC;  // Declare debug()

src/V3Tristate.cpp

@@ -117,7 +117,7 @@ class TristateGraph final {
 
     // TYPES
 public:
-    typedef std::vector<AstVar*> VarVec;
+    using VarVec = std::vector<AstVar*>;
 
 private:
     // MEMBERS
@@ -328,8 +328,8 @@ class TristateVisitor final : public TristateBaseVisitor {
     AstUser5InUse m_inuser5;
 
     // TYPES
-    typedef std::vector<AstVarRef*> RefVec;
-    typedef std::unordered_map<AstVar*, RefVec*> VarMap;
+    using RefVec = std::vector<AstVarRef*>;
+    using VarMap = std::unordered_map<AstVar*, RefVec*>;
     enum : uint8_t {
         U2_GRAPHING = 1,  // bit[0] if did m_graphing visit
         U2_NONGRAPH = 2,  // bit[1] if did !m_graphing visit

src/V3Waiver.h

@@ -24,7 +24,7 @@
 
 class V3Waiver final {
     // TYPES
-    typedef std::vector<std::string> WaiverList;
+    using WaiverList = std::vector<std::string>;
     static WaiverList s_waiverList;
 
 public:

src/V3Width.cpp

@@ -198,8 +198,8 @@ public:
 class WidthVisitor final : public AstNVisitor {
 private:
     // TYPES
-    typedef std::map<std::pair<const AstNodeDType*, AstAttrType>, AstVar*> TableMap;
-    typedef std::map<int, AstPatMember*> PatVecMap;
+    using TableMap = std::map<std::pair<const AstNodeDType*, AstAttrType>, AstVar*>;
+    using PatVecMap = std::map<int, AstPatMember*>;
 
     // STATE
     WidthVP* m_vup = nullptr;  // Current node state

src/VlcOptions.h

@@ -29,7 +29,7 @@
 //######################################################################
 // V3Options - Command line options
 
-typedef std::set<string> VlStringSet;
+using VlStringSet = std::set<std::string>;
 
 class VlcOptions final {
     // MEMBERS (general options)

src/VlcPoint.h

@@ -93,15 +93,15 @@ public:
 class VlcPoints final {
 private:
     // MEMBERS
-    typedef std::map<const string, vluint64_t> NameMap;  // Sorted by name (ordered)
+    using NameMap = std::map<const std::string, vluint64_t>;  // Sorted by name (ordered)
     NameMap m_nameMap;  //< Name to point-number
     std::vector<VlcPoint> m_points;  //< List of all points
     vluint64_t m_numPoints = 0;  //< Total unique points
 
 public:
     // ITERATORS
-    typedef NameMap ByName;
-    typedef ByName::iterator iterator;
+    using ByName = NameMap;
+    using iterator = ByName::iterator;
     ByName::iterator begin() { return m_nameMap.begin(); }
     ByName::iterator end() { return m_nameMap.end(); }
 

src/VlcSource.h

@@ -60,8 +60,8 @@ public:
 class VlcSource final {
 public:
     // TYPES
-    typedef std::map<int, VlcSourceCount> ColumnMap;  // Map of {column}
-    typedef std::map<int, ColumnMap> LinenoMap;  // Map of {lineno}{column}
+    using ColumnMap = std::map<int, VlcSourceCount>;  // Map of {column}
+    using LinenoMap = std::map<int, ColumnMap>;  // Map of {lineno}{column}
 
 private:
     // MEMBERS
@@ -101,7 +101,7 @@ public:
 class VlcSources final {
 public:
     // TYPES
-    typedef std::map<const string, VlcSource> NameMap;
+    using NameMap = std::map<const std::string, VlcSource>;
 
 private:
     // MEMBERS
@@ -109,7 +109,7 @@ private:
 
 public:
     // ITERATORS
-    typedef NameMap::iterator iterator;
+    using iterator = NameMap::iterator;
     NameMap::iterator begin() { return m_sources.begin(); }
     NameMap::iterator end() { return m_sources.end(); }
 

src/VlcTest.h

@@ -87,7 +87,7 @@ public:
 class VlcTests final {
 public:
     // TYPES
-    typedef std::vector<VlcTest*> ByName;
+    using ByName = std::vector<VlcTest*>;
 
 private:
     // MEMBERS
@@ -95,7 +95,7 @@ private:
 
 public:
     // ITERATORS
-    typedef ByName::iterator iterator;
+    using iterator = ByName::iterator;
     ByName::iterator begin() { return m_tests.begin(); }
     ByName::iterator end() { return m_tests.end(); }
 

src/config_build.h.in

@@ -67,7 +67,7 @@
 #include <iostream>
 
 // Avoid needing std:: prefixes on some very common items
-typedef std::string string;
+using string = std::string;
 using std::cout;
 using std::endl;
 using std::make_pair;