From c7aa95439c0391db1f0fbe0e1561d8ab0ba05d85 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Tue, 1 Sep 2026 20:10:04 -0400 Subject: [PATCH] Internals: Cleanup some member name vs accessor name mismatches. No functional change. --- src/V3Assert.cpp | 18 +++++++-------- src/V3AstNodeExpr.h | 16 +++++++------- src/V3AstNodeOther.h | 52 ++++++++++++++++++++++---------------------- src/V3AstNodeStmt.h | 8 +++---- src/V3AstNodes.cpp | 16 +++++++------- src/V3Covergroup.cpp | 6 ++--- src/V3LinkParse.cpp | 8 +++---- src/V3Width.cpp | 4 ++-- 8 files changed, 64 insertions(+), 64 deletions(-) diff --git a/src/V3Assert.cpp b/src/V3Assert.cpp index acddfdfb7..5c935b1bb 100644 --- a/src/V3Assert.cpp +++ b/src/V3Assert.cpp @@ -1256,9 +1256,9 @@ class AssertVisitor final : public VNVisitor { bool assertTypeConst = true; if (!nodep->assertTypesp()) { - nodep->ctlAssertTypes(VAssertType{ALL_ASSERT_TYPES}); + nodep->assertTypes(VAssertType{ALL_ASSERT_TYPES}); } else if (const AstConst* const assertTypesp = VN_CAST(nodep->assertTypesp(), Const)) { - nodep->ctlAssertTypes(VAssertType{assertTypesp->toSInt()}); + nodep->assertTypes(VAssertType{assertTypesp->toSInt()}); } else { assertTypeConst = false; } @@ -1278,9 +1278,9 @@ class AssertVisitor final : public VNVisitor { VL_DO_DANGLING(pushDeletep(nodep), nodep); return; } - if (assertTypeConst && nodep->ctlAssertTypes() != ALL_ASSERT_TYPES - && nodep->ctlAssertTypes().containsAny(VAssertType::UNIQUE | VAssertType::UNIQUE0 - | VAssertType::PRIORITY)) { + if (assertTypeConst && nodep->assertTypes() != ALL_ASSERT_TYPES + && nodep->assertTypes().containsAny(VAssertType::UNIQUE | VAssertType::UNIQUE0 + | VAssertType::PRIORITY)) { nodep->v3warn(E_UNSUPPORTED, "Unsupported: assert control assertion_type"); VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep); return; @@ -1288,11 +1288,11 @@ class AssertVisitor final : public VNVisitor { bool directiveTypeConst = true; if (!nodep->directiveTypesp()) { - nodep->ctlDirectiveTypes(VAssertDirectiveType::ASSERT | VAssertDirectiveType::ASSUME - | VAssertDirectiveType::COVER); + nodep->directiveTypes(VAssertDirectiveType::ASSERT | VAssertDirectiveType::ASSUME + | VAssertDirectiveType::COVER); } else if (const AstConst* const directiveTypesp = VN_CAST(nodep->directiveTypesp(), Const)) { - nodep->ctlDirectiveTypes(VAssertDirectiveType{directiveTypesp->toSInt()}); + nodep->directiveTypes(VAssertDirectiveType{directiveTypesp->toSInt()}); } else { directiveTypeConst = false; } @@ -1314,7 +1314,7 @@ class AssertVisitor final : public VNVisitor { } else { newp->add(std::to_string(ALL_ASSERT_TYPES)); } - newp->add(", " + std::to_string(nodep->ctlDirectiveTypes()) + ");\n"); + newp->add(", " + std::to_string(nodep->directiveTypes()) + ");\n"); nodep->replaceWith(newp); VL_DO_DANGLING(pushDeletep(nodep), nodep); } diff --git a/src/V3AstNodeExpr.h b/src/V3AstNodeExpr.h index a6e4d9c66..a6d9afad1 100644 --- a/src/V3AstNodeExpr.h +++ b/src/V3AstNodeExpr.h @@ -5421,17 +5421,17 @@ public: enum FmtType : int { ATOI = 10, ATOHEX = 16, ATOOCT = 8, ATOBIN = 2, ATOREAL = -1 }; private: - const FmtType m_fmt; // Operation type + const FmtType m_fmtType; // Operation type public: - AstAtoN(FileLine* fl, AstNodeExpr* lhsp, FmtType fmt) + AstAtoN(FileLine* fl, AstNodeExpr* lhsp, FmtType fmtType) : ASTGEN_SUPER_AtoN(fl, lhsp) - , m_fmt{fmt} { - fmt == ATOREAL ? dtypeSetDouble() : dtypeSetInteger(); + , m_fmtType{fmtType} { + fmtType == ATOREAL ? dtypeSetDouble() : dtypeSetInteger(); } ASTGEN_MEMBERS_AstAtoN; - void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAtoN(lhs, m_fmt); } + void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAtoN(lhs, m_fmtType); } string name() const override VL_MT_STABLE { - switch (m_fmt) { + switch (m_fmtType) { case ATOI: return "atoi"; case ATOHEX: return "atohex"; case ATOOCT: return "atooct"; @@ -5442,7 +5442,7 @@ public: } string emitVerilog() override { return "%l." + name() + "()"; } string emitC() override { - switch (m_fmt) { + switch (m_fmtType) { case ATOI: return "VL_ATOI_N(%li, 10)"; case ATOHEX: return "VL_ATOI_N(%li, 16)"; case ATOOCT: return "VL_ATOI_N(%li, 8)"; @@ -5454,7 +5454,7 @@ public: bool cleanOut() const override { return true; } bool cleanLhs() const override { return true; } bool sizeMattersLhs() const override { return false; } - FmtType format() const { return m_fmt; } + FmtType fmtType() const { return m_fmtType; } }; class AstBitsToRealD final : public AstNodeUniop { public: diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h index 1f3f46c43..0bf4d78c0 100644 --- a/src/V3AstNodeOther.h +++ b/src/V3AstNodeOther.h @@ -517,7 +517,7 @@ class AstCFunc final : public AstNode { string m_rtnType; // void, bool, or other return type string m_argTypes; // Argument types string m_ifdef; // #ifdef symbol around this function - string m_cDecl; // Custom DPI-C function declaration + string m_dpiCDecl; // Custom DPI-C function declaration VBoolOrUnknown m_isConst; // Function is declared const (*this not changed) bool m_isStatic : 1; // Function is static (no need for a 'this' pointer) bool m_isTrace : 1; // Function is related to tracing @@ -647,9 +647,9 @@ public: void dpiImportPrototype(bool flag) { m_dpiImportPrototype = flag; } bool dpiImportWrapper() const { return m_dpiImportWrapper; } void dpiImportWrapper(bool flag) { m_dpiImportWrapper = flag; } - bool dpiCDeclOverride() const { return !m_cDecl.empty(); } - const string& dpiCDecl() const { return m_cDecl; } - void dpiCDecl(const string& cDecl) { m_cDecl = cDecl; } + bool dpiCDeclOverride() const { return !m_dpiCDecl.empty(); } + const string& dpiCDecl() const { return m_dpiCDecl; } + void dpiCDecl(const string& cDecl) { m_dpiCDecl = cDecl; } bool isCoroutine() const { return m_rtnType == "VlCoroutine"; } void recursive(bool flag) { m_recursive = flag; } bool recursive() const { return m_recursive; } @@ -806,7 +806,7 @@ public: void dump(std::ostream& str) const override; void dumpJson(std::ostream& str) const override; string name() const override VL_MT_STABLE { return m_name; } - VCoverOptionType optionType() const { return m_optType; } + VCoverOptionType optType() const { return m_optType; } bool typeOption() const { return m_typeOption; } }; class AstClassExtends final : public AstNode { @@ -1050,7 +1050,7 @@ class AstCoverBin final : public AstNode { // @astgen op3 := arraySizep : Optional[AstNodeExpr] // @astgen op4 := transp : List[AstCoverTransSet] const string m_name; // Base name of the bin - const VCoverBinsType m_type; // Bin type (eg AUTO, IGNORE, ILLEGAL) + const VCoverBinsType m_binsType; // Bin type (eg AUTO, IGNORE, ILLEGAL) bool m_isArray = false; // Bin is either an auto-sized array of values or transitions bool m_isWildcard = false; // Bin uses wildcard matching (independent of ignore/illegal) @@ -1059,10 +1059,10 @@ public: bool isWildcard = false) : ASTGEN_SUPER_CoverBin(fl) , m_name{name} - , m_type{isIllegal ? VCoverBinsType::BINS_ILLEGAL - : (isIgnore ? VCoverBinsType::BINS_IGNORE - : (isWildcard ? VCoverBinsType::BINS_WILDCARD - : VCoverBinsType::BINS_USER))} + , m_binsType{isIllegal ? VCoverBinsType::BINS_ILLEGAL + : (isIgnore ? VCoverBinsType::BINS_IGNORE + : (isWildcard ? VCoverBinsType::BINS_WILDCARD + : VCoverBinsType::BINS_USER))} , m_isWildcard{isWildcard} { addRangesp(rangesp); } @@ -1070,7 +1070,7 @@ public: AstCoverBin(FileLine* fl, const string& name, AstNodeExpr* arraySizep) : ASTGEN_SUPER_CoverBin(fl) , m_name{name} - , m_type{VCoverBinsType::BINS_AUTO} + , m_binsType{VCoverBinsType::BINS_AUTO} , m_isArray{true} { this->arraySizep(arraySizep); } @@ -1078,13 +1078,13 @@ public: AstCoverBin(FileLine* fl, const string& name, VCoverBinsType type) : ASTGEN_SUPER_CoverBin(fl) , m_name{name} - , m_type{type} {} + , m_binsType{type} {} // Constructor for transition bins AstCoverBin(FileLine* fl, const string& name, AstCoverTransSet* transp, VCoverBinsType type = VCoverBinsType::BINS_TRANSITION, bool isArrayBin = false) : ASTGEN_SUPER_CoverBin(fl) , m_name{name} - , m_type{type} + , m_binsType{type} , m_isArray{isArrayBin} { UASSERT(transp, "AstCoverBin transition constructor requires non-null transp"); addTransp(transp); @@ -1093,7 +1093,7 @@ public: void dump(std::ostream& str) const override; void dumpJson(std::ostream& str) const override; string name() const override VL_MT_STABLE { return m_name; } - VCoverBinsType binsType() const { return m_type; } + VCoverBinsType binsType() const { return m_binsType; } bool isWildcard() const { return m_isWildcard; } bool isArray() const { return m_isArray; } void isArray(bool flag) { m_isArray = flag; } @@ -1101,18 +1101,18 @@ public: class AstCoverOption final : public AstNode { // Coverage-option assignment // @astgen op1 := valuep : AstNodeExpr - const VCoverOptionType m_type; // Option being assigned + const VCoverOptionType m_optType; // Option being assigned public: - AstCoverOption(FileLine* fl, VCoverOptionType type, AstNodeExpr* valuep) + AstCoverOption(FileLine* fl, VCoverOptionType optType, AstNodeExpr* valuep) : ASTGEN_SUPER_CoverOption(fl) - , m_type{type} { + , m_optType{optType} { this->valuep(valuep); } ASTGEN_MEMBERS_AstCoverOption; void dump(std::ostream& str) const override; void dumpJson(std::ostream& str) const override; - VCoverOptionType optionType() const { return m_type; } + VCoverOptionType optType() const { return m_optType; } }; class AstCoverTransItem final : public AstNode { // Represents a single transition item: value or value[*N] or value[->N] or value[=N] @@ -2161,7 +2161,7 @@ class AstVar final : public AstNode { bool m_attrFsmArcInclCond : 1; // declared with fsm_arc_include_cond metacomment bool m_constPoolEntry : 1; // Constant pool variable bool m_covergroupRefMember : 1; // Persistent covergroup ref/const ref argument - bool m_fileDescr : 1; // File descriptor + bool m_attrFileDescr : 1; // File descriptor bool m_gotNansiType : 1; // Linker saw Non-ANSI type declaration bool m_icoMaybeWritten : 1; // Design might write this input signal - for ico change detect bool m_isConst : 1; // Table contains constant data @@ -2182,7 +2182,7 @@ class AstVar final : public AstNode { bool m_noSubst : 1; // Do not substitute out references bool m_sampled : 1; // Sampled timing region bool m_substConstOnly : 1; // Only substitute if constant - bool m_overridenParam : 1; // Overridden parameter by #(...) or defparam + bool m_overriddenParam : 1; // Overridden parameter by #(...) or defparam bool m_trace : 1; // Trace this variable bool m_isLatched : 1; // Not assigned in all control paths of combo always bool m_isForceable : 1; // May be forced/released externally from user C code @@ -2226,7 +2226,7 @@ class AstVar final : public AstNode { m_attrFsmArcInclCond = false; m_constPoolEntry = false; m_covergroupRefMember = false; - m_fileDescr = false; + m_attrFileDescr = false; m_gotNansiType = false; m_icoMaybeWritten = false; m_isConst = false; @@ -2247,7 +2247,7 @@ class AstVar final : public AstNode { m_noSubst = false; m_sampled = false; m_substConstOnly = false; - m_overridenParam = false; + m_overriddenParam = false; m_trace = false; m_isLatched = false; m_isForceable = false; @@ -2366,7 +2366,7 @@ public: void ansi(bool flag) { m_ansi = flag; } void declTyped(bool flag) { m_declTyped = flag; } void sensIfacep(AstIface* nodep) { m_sensIfacep = nodep; } - void attrFileDescr(bool flag) { m_fileDescr = flag; } + void attrFileDescr(bool flag) { m_attrFileDescr = flag; } void attrScBv(bool flag) { m_attrScBv = flag; } void attrScBigUint(bool flag) { m_attrScBigUint = flag; } void attrSFormat(bool flag) { m_attrSFormat = flag; } @@ -2432,8 +2432,8 @@ public: void sampled(bool flag) { m_sampled = flag; } bool substConstOnly() const { return m_substConstOnly; } void substConstOnly(bool flag) { m_substConstOnly = flag; } - bool overriddenParam() const { return m_overridenParam; } - void overriddenParam(bool flag) { m_overridenParam = flag; } + bool overriddenParam() const { return m_overriddenParam; } + void overriddenParam(bool flag) { m_overriddenParam = flag; } void trace(bool flag) { m_trace = flag; } void isLatched(bool flag) { m_isLatched = flag; } bool isForceable() const { return m_isForceable; } @@ -2537,7 +2537,7 @@ public: bool isPulldown() const { return m_isPulldown; } bool attrScBv() const { return m_attrScBv; } bool attrScBigUint() const { return m_attrScBigUint; } - bool attrFileDescr() const { return m_fileDescr; } + bool attrFileDescr() const { return m_attrFileDescr; } bool attrSFormat() const { return m_attrSFormat; } bool attrSplitVar() const { return m_attrSplitVar; } bool attrFsmState() const { return m_attrFsmState; } diff --git a/src/V3AstNodeStmt.h b/src/V3AstNodeStmt.h index a6ca93d3d..456c29bd5 100644 --- a/src/V3AstNodeStmt.h +++ b/src/V3AstNodeStmt.h @@ -262,10 +262,10 @@ public: bool isOutputter() override { return true; } VAssertCtlType ctlType() const { return m_ctlType; } void ctlType(int32_t type) { m_ctlType = VAssertCtlType{type}; } - VAssertType ctlAssertTypes() const { return m_assertTypes; } - void ctlAssertTypes(VAssertType types) { m_assertTypes = types; } - VAssertDirectiveType ctlDirectiveTypes() const { return m_directiveTypes; } - void ctlDirectiveTypes(VAssertDirectiveType types) { m_directiveTypes = types; } + VAssertType assertTypes() const { return m_assertTypes; } + void assertTypes(VAssertType types) { m_assertTypes = types; } + VAssertDirectiveType directiveTypes() const { return m_directiveTypes; } + void directiveTypes(VAssertDirectiveType types) { m_directiveTypes = types; } void dump(std::ostream& str = std::cout) const override; void dumpJson(std::ostream& str = std::cout) const override; }; diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp index 66efa3622..26ec24f88 100644 --- a/src/V3AstNodes.cpp +++ b/src/V3AstNodes.cpp @@ -1982,15 +1982,15 @@ void AstAssertCtl::dump(std::ostream& str) const { this->AstNode::dump(str); if (ctlType() != VAssertCtlType::_TO_BE_EVALUATED) { str << " [" << ctlType().ascii() << "]"; - str << " [" << ctlAssertTypes().ascii() << "]"; - str << " [" << ctlDirectiveTypes().ascii() << "]"; + str << " [" << assertTypes().ascii() << "]"; + str << " [" << directiveTypes().ascii() << "]"; } } void AstAssertCtl::dumpJson(std::ostream& str) const { if (ctlType() != VAssertCtlType::_TO_BE_EVALUATED) { dumpJsonStr(str, "ctlType", ctlType().ascii()); - dumpJsonStr(str, "ctlAssertTypes", ctlAssertTypes().ascii()); - dumpJsonStr(str, "ctlDirectiveTypes", ctlDirectiveTypes().ascii()); + dumpJsonStr(str, "assertTypes", assertTypes().ascii()); + dumpJsonStr(str, "directiveTypes", directiveTypes().ascii()); } dumpJsonGen(str); } @@ -3985,13 +3985,13 @@ void AstCoverpoint::dumpJson(std::ostream& str) const { this->AstNodeFuncCovItem void AstCoverBin::dump(std::ostream& str) const { this->AstNode::dump(str); - str << " " << m_type.ascii(); + str << " " << m_binsType.ascii(); if (m_isArray) str << "[]"; } void AstCoverBin::dumpJson(std::ostream& str) const { this->AstNode::dumpJson(str); - str << ", \"binsType\": \"" << m_type.ascii() << "\""; + str << ", \"binsType\": \"" << binsType().ascii() << "\""; if (m_isArray) str << ", \"isArray\": true"; } @@ -4015,12 +4015,12 @@ void AstCoverCross::dumpJson(std::ostream& str) const { this->AstNodeFuncCovItem void AstCoverOption::dump(std::ostream& str) const { this->AstNode::dump(str); - str << " " << m_type.ascii(); + str << " " << m_optType.ascii(); } void AstCoverOption::dumpJson(std::ostream& str) const { this->AstNode::dumpJson(str); - str << ", \"optionType\": \"" << m_type.ascii() << "\""; + str << ", \"optType\": \"" << m_optType.ascii() << "\""; } void AstCoverpointRef::dump(std::ostream& str) const { this->AstNode::dump(str); } diff --git a/src/V3Covergroup.cpp b/src/V3Covergroup.cpp index 577bfae06..77bb9d1fb 100644 --- a/src/V3Covergroup.cpp +++ b/src/V3Covergroup.cpp @@ -311,16 +311,16 @@ class FunctionalCoverageVisitor final : public VNVisitor { AstConst* const constp = VN_CAST(optp->valuep(), Const); if (!constp) { optp->valuep()->v3warn(COVERIGN, "Ignoring unsupported: non-constant 'option." - << optp->optionType().ascii() + << optp->optType().ascii() << "'; using default value"); continue; } - if (optp->optionType() == VCoverOptionType::AT_LEAST) { + if (optp->optType() == VCoverOptionType::AT_LEAST) { atLeastOut = constp->toSInt(); } else { // V3LinkParse only converts at_least/auto_bin_max coverpoint options into // AstCoverOption (others are dropped there), so this is the only alternative. - UASSERT_OBJ(optp->optionType() == VCoverOptionType::AUTO_BIN_MAX, optp, + UASSERT_OBJ(optp->optType() == VCoverOptionType::AUTO_BIN_MAX, optp, "Unexpected coverpoint option type reaching V3Covergroup"); autoBinMaxOut = constp->toSInt(); } diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp index d032eaabc..07c1a63e7 100644 --- a/src/V3LinkParse.cpp +++ b/src/V3LinkParse.cpp @@ -1401,9 +1401,9 @@ class LinkParseVisitor final : public VNVisitor { nextp = itemp->nextp(); if (AstCgOptionAssign* const optp = VN_CAST(itemp, CgOptionAssign)) { optp->unlinkFrBack(); - if (optp->optionType() == VCoverOptionType::AT_LEAST - || optp->optionType() == VCoverOptionType::AUTO_BIN_MAX) { - nodep->addOptionsp(new AstCoverOption{optp->fileline(), optp->optionType(), + if (optp->optType() == VCoverOptionType::AT_LEAST + || optp->optType() == VCoverOptionType::AUTO_BIN_MAX) { + nodep->addOptionsp(new AstCoverOption{optp->fileline(), optp->optType(), optp->valuep()->cloneTree(false)}); } else { optp->v3warn(COVERIGN, @@ -1425,7 +1425,7 @@ class LinkParseVisitor final : public VNVisitor { nextp = itemp->nextp(); itemp->unlinkFrBack(); AstCgOptionAssign* const optp = VN_AS(itemp, CgOptionAssign); - const VCoverOptionType optType = optp->optionType(); + const VCoverOptionType optType = optp->optType(); optp->v3warn(COVERIGN, "Ignoring unsupported coverage cross option: " + optp->prettyNameQ()); // Always preserve the option node so V3Coverage can track its source line diff --git a/src/V3Width.cpp b/src/V3Width.cpp index e90dc6b46..3eb756bfd 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -506,7 +506,7 @@ class WidthVisitor final : public VNVisitor { if (m_vup->prelim()) { // See similar handling in visit_cmp_eq_gt where created iterateCheckString(nodep, "LHS", nodep->lhsp(), BOTH); - if (nodep->format() == AstAtoN::ATOREAL) { + if (nodep->fmtType() == AstAtoN::ATOREAL) { nodep->dtypeSetDouble(); } else { nodep->dtypeSetInteger(); @@ -2045,7 +2045,7 @@ class WidthVisitor final : public VNVisitor { // Extract covergroup option values and store in AstClass before deleting. // m_cgClassp is always set here: AstCgOptionAssign only appears in covergroup // class bodies, and visitClass sets m_cgClassp before iterating children. - if (nodep->optionType() == VCoverOptionType::AUTO_BIN_MAX) { + if (nodep->optType() == VCoverOptionType::AUTO_BIN_MAX) { // By V3Width time, V3Param has already folded any parameter references. // If the value is still not a constant, it is a runtime expression - emit error. if (AstConst* constp = VN_CAST(nodep->valuep(), Const)) {