[clang-tidy] Enable the misc-no-recursion check

dergoegge · stickies-v · glozow · dergoegge · commit 78407b99ed6d · 2024-04-07T14:04:45.000+01:00
Co-authored-by: stickies-v &lt;stickies-v@protonmail.com&gt;
Co-authored-by: Gloria Zhao &lt;gloriajzhao@gmail.com&gt;
diff --git a/doc/developer-notes.md b/doc/developer-notes.md
@@ -115,6 +115,8 @@ code.
     Use `reinterpret_cast` and `const_cast` as appropriate.
   - Prefer [`list initialization ({})`](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-list) where possible.
     For example `int x{0};` instead of `int x = 0;` or `int x(0);`
+  - Recursion is checked by clang-tidy and thus must be made explicit. Use
+    `NOLINTNEXTLINE(misc-no-recursion)` to suppress the check.
 
 For function calls a namespace should be specified explicitly, unless such functions have been declared within it.
 Otherwise, [argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl), also known as ADL, could be
diff --git a/src/.clang-tidy b/src/.clang-tidy
@@ -6,6 +6,7 @@ bugprone-string-constructor,
 bugprone-use-after-move,
 bugprone-lambda-function-name,
 misc-unused-using-decls,
+misc-no-recursion,
 modernize-use-default-member-init,
 modernize-use-emplace,
 modernize-use-noexcept,
diff --git a/src/merkleblock.cpp b/src/merkleblock.cpp
@@ -54,6 +54,7 @@ CMerkleBlock::CMerkleBlock(const CBlock& block, CBloomFilter* filter, const std:
     txn = CPartialMerkleTree(vHashes, vMatch);
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::vector<uint256> &vTxid) {
     //we can never have zero txs in a merkle block, we always need the coinbase tx
     //if we do not have this assert, we can hit a memory access violation when indexing into vTxid
@@ -74,6 +75,7 @@ uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::ve
     }
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 void CPartialMerkleTree::TraverseAndBuild(int height, unsigned int pos, const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch) {
     // determine whether this node is the parent of at least one matched txid
     bool fParentOfMatch = false;
@@ -92,6 +94,7 @@ void CPartialMerkleTree::TraverseAndBuild(int height, unsigned int pos, const st
     }
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, unsigned int &nBitsUsed, unsigned int &nHashUsed, std::vector<uint256> &vMatch, std::vector<unsigned int> &vnIndex) {
     if (nBitsUsed >= vBits.size()) {
         // overflowed the bits array - failure
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
@@ -406,6 +406,7 @@ class NodeImpl : public Node
     NodeContext* m_context{nullptr};
 };
 
+// NOLINTNEXTLINE(misc-no-recursion)
 bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active, const BlockManager& blockman)
 {
     if (!index) return false;
diff --git a/src/qt/optionsmodel.cpp b/src/qt/optionsmodel.cpp
@@ -396,6 +396,7 @@ bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, in
     return successful;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 QVariant OptionsModel::getOption(OptionID option, const std::string& suffix) const
 {
     auto setting = [&]{ return node().getPersistentSetting(SettingName(option) + suffix); };
@@ -508,6 +509,7 @@ QFont OptionsModel::getFontForMoney() const
     return getFontForChoice(m_font_money);
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 bool OptionsModel::setOption(OptionID option, const QVariant& value, const std::string& suffix)
 {
     auto changed = [&] { return value.isValid() && value != getOption(option, suffix); };
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
@@ -414,6 +414,7 @@ struct Sections {
     /**
      * Recursive helper to translate an RPCArg into sections
      */
+    // NOLINTNEXTLINE(misc-no-recursion)
     void Push(const RPCArg& arg, const size_t current_indent = 5, const OuterType outer_type = OuterType::NONE)
     {
         const auto indent = std::string(current_indent, ' ');
@@ -953,6 +954,7 @@ std::string RPCArg::ToDescriptionString(bool is_named_arg) const
     return ret;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const int current_indent) const
 {
     // Indentation
@@ -1086,6 +1088,7 @@ static std::optional<UniValue::VType> ExpectedType(RPCResult::Type type)
     NONFATAL_UNREACHABLE();
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 UniValue RPCResult::MatchesType(const UniValue& result) const
 {
     if (m_skip_type_check) {
@@ -1164,6 +1167,7 @@ void RPCResult::CheckInnerDoc() const
     CHECK_NONFATAL(inner_needed != m_inner.empty());
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 std::string RPCArg::ToStringObj(const bool oneline) const
 {
     std::string res;
@@ -1202,6 +1206,7 @@ std::string RPCArg::ToStringObj(const bool oneline) const
     NONFATAL_UNREACHABLE();
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 std::string RPCArg::ToString(const bool oneline) const
 {
     if (oneline && !m_opts.oneline_description.empty()) {
@@ -1228,6 +1233,7 @@ std::string RPCArg::ToString(const bool oneline) const
     case Type::OBJ:
     case Type::OBJ_NAMED_PARAMS:
     case Type::OBJ_USER_KEYS: {
+        // NOLINTNEXTLINE(misc-no-recursion)
         const std::string res = Join(m_inner, ",", [&](const RPCArg& i) { return i.ToStringObj(oneline); });
         if (m_type == Type::OBJ) {
             return "{" + res + "}";
diff --git a/src/rpc/util.h b/src/rpc/util.h
@@ -162,6 +162,7 @@ struct RPCArgOptions {
                                          //!< methods set the also_positional flag and read values from both positions.
 };
 
+// NOLINTNEXTLINE(misc-no-recursion)
 struct RPCArg {
     enum class Type {
         OBJ,
@@ -271,6 +272,7 @@ struct RPCArg {
     std::string ToDescriptionString(bool is_named_arg) const;
 };
 
+// NOLINTNEXTLINE(misc-no-recursion)
 struct RPCResult {
     enum class Type {
         OBJ,
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
@@ -599,6 +599,7 @@ class DescriptorImpl : public Descriptor
         COMPAT, // string calculation that mustn't change over time to stay compatible with previous software versions
     };
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     bool IsSolvable() const override
     {
         for (const auto& arg : m_subdescriptor_args) {
@@ -607,6 +608,7 @@ class DescriptorImpl : public Descriptor
         return true;
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     bool IsRange() const final
     {
         for (const auto& pubkey : m_pubkey_args) {
@@ -618,6 +620,7 @@ class DescriptorImpl : public Descriptor
         return false;
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     virtual bool ToStringSubScriptHelper(const SigningProvider* arg, std::string& ret, const StringType type, const DescriptorCache* cache = nullptr) const
     {
         size_t pos = 0;
@@ -630,6 +633,7 @@ class DescriptorImpl : public Descriptor
         return true;
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     virtual bool ToStringHelper(const SigningProvider* arg, std::string& out, const StringType type, const DescriptorCache* cache = nullptr) const
     {
         std::string extra = ToStringExtra();
@@ -682,6 +686,7 @@ class DescriptorImpl : public Descriptor
         return ret;
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     bool ExpandHelper(int pos, const SigningProvider& arg, const DescriptorCache* read_cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out, DescriptorCache* write_cache) const
     {
         std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;
@@ -723,6 +728,7 @@ class DescriptorImpl : public Descriptor
         return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, &read_cache, output_scripts, out, nullptr);
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     void ExpandPrivate(int pos, const SigningProvider& provider, FlatSigningProvider& out) const final
     {
         for (const auto& p : m_pubkey_args) {
@@ -750,6 +756,7 @@ class DescriptorImpl : public Descriptor
 
     std::optional<int64_t> MaxSatisfactionElems() const override { return {}; }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     void GetPubKeys(std::set<CPubKey>& pubkeys, std::set<CExtPubKey>& ext_pubs) const override
     {
         for (const auto& p : m_pubkey_args) {
@@ -1579,6 +1586,7 @@ struct KeyParser {
 };
 
 /** Parse a script in a particular context. */
+// NOLINTNEXTLINE(misc-no-recursion)
 std::unique_ptr<DescriptorImpl> ParseScript(uint32_t& key_exp_index, Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, std::string& error)
 {
     using namespace spanparsing;
@@ -1886,6 +1894,7 @@ std::unique_ptr<DescriptorImpl> InferMultiA(const CScript& script, ParseScriptCo
     return std::make_unique<MultiADescriptor>(match->first, std::move(keys));
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptContext ctx, const SigningProvider& provider)
 {
     if (ctx == ParseScriptContext::P2TR && script.size() == 34 && script[0] == 32 && script[33] == OP_CHECKSIG) {
diff --git a/src/test/miniscript_tests.cpp b/src/test/miniscript_tests.cpp
@@ -297,6 +297,7 @@ using miniscript::operator"" _mst;
 using Node = miniscript::Node<CPubKey>;
 
 /** Compute all challenges (pubkeys, hashes, timelocks) that occur in a given Miniscript. */
+// NOLINTNEXTLINE(misc-no-recursion)
 std::set<Challenge> FindChallenges(const NodeRef& ref) {
     std::set<Challenge> chal;
     for (const auto& key : ref->keys) {
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
@@ -127,6 +127,7 @@ std::shared_ptr<const CBlock> MinerTestingSetup::BadBlock(const uint256& prev_ha
     return ret;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 void MinerTestingSetup::BuildChain(const uint256& root, int height, const unsigned int invalid_rate, const unsigned int branch_rate, const unsigned int max_size, std::vector<std::shared_ptr<const CBlock>>& blocks)
 {
     if (height <= 0 || blocks.size() >= max_size) return;
diff --git a/src/univalue/include/univalue.h b/src/univalue/include/univalue.h
@@ -18,6 +18,7 @@
 #include <utility>
 #include <vector>
 
+// NOLINTNEXTLINE(misc-no-recursion)
 class UniValue {
 public:
     enum VType { VNULL, VOBJ, VARR, VSTR, VNUM, VBOOL, };
diff --git a/src/univalue/lib/univalue_write.cpp b/src/univalue/lib/univalue_write.cpp
@@ -27,6 +27,7 @@ static std::string json_escape(const std::string& inS)
     return outS;
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 std::string UniValue::write(unsigned int prettyIndent,
                             unsigned int indentLevel) const
 {
@@ -66,6 +67,7 @@ static void indentStr(unsigned int prettyIndent, unsigned int indentLevel, std::
     s.append(prettyIndent * indentLevel, ' ');
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const
 {
     s += "[";
@@ -88,6 +90,7 @@ void UniValue::writeArray(unsigned int prettyIndent, unsigned int indentLevel, s
     s += "]";
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 void UniValue::writeObject(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const
 {
     s += "{";
diff --git a/src/util/string.h b/src/util/string.h
@@ -65,6 +65,7 @@ void ReplaceAll(std::string& in_out, const std::string& search, const std::strin
  * @param unary_op  Apply this operator to each item
  */
 template <typename C, typename S, typename UnaryOp>
+// NOLINTNEXTLINE(misc-no-recursion)
 auto Join(const C& container, const S& separator, UnaryOp unary_op)
 {
     decltype(unary_op(*container.begin())) ret;
diff --git a/src/wallet/receive.cpp b/src/wallet/receive.cpp
@@ -253,6 +253,7 @@ bool CachedTxIsFromMe(const CWallet& wallet, const CWalletTx& wtx, const isminef
     return (CachedTxGetDebit(wallet, wtx, filter) > 0);
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 bool CachedTxIsTrusted(const CWallet& wallet, const CWalletTx& wtx, std::set<uint256>& trusted_parents)
 {
     AssertLockHeld(wallet.cs_wallet);
diff --git a/src/wallet/rpc/addresses.cpp b/src/wallet/rpc/addresses.cpp
@@ -395,6 +395,7 @@ class DescribeWalletAddressVisitor
 public:
     const SigningProvider * const provider;
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     void ProcessSubScript(const CScript& subscript, UniValue& obj) const
     {
         // Always present: script type and redeemscript
@@ -445,6 +446,7 @@ class DescribeWalletAddressVisitor
         return obj;
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     UniValue operator()(const ScriptHash& scripthash) const
     {
         UniValue obj(UniValue::VOBJ);
@@ -465,6 +467,7 @@ class DescribeWalletAddressVisitor
         return obj;
     }
 
+    // NOLINTNEXTLINE(misc-no-recursion)
     UniValue operator()(const WitnessV0ScriptHash& id) const
     {
         UniValue obj(UniValue::VOBJ);
diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp
@@ -854,6 +854,7 @@ enum class ScriptContext
 
 // Analyse the provided scriptPubKey, determining which keys and which redeem scripts from the ImportData struct are needed to spend it, and mark them as used.
 // Returns an error string, or the empty string for success.
+// NOLINTNEXTLINE(misc-no-recursion)
 static std::string RecurseImportData(const CScript& script, ImportData& import_data, const ScriptContext script_ctx)
 {
     // Use Solver to obtain script type and parsed pubkeys or hashes:
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
@@ -97,6 +97,7 @@ bool HaveKeys(const std::vector<valtype>& pubkeys, const LegacyScriptPubKeyMan&
 //! @param recurse_scripthash  whether to recurse into nested p2sh and p2wsh
 //!                            scripts or simply treat any script that has been
 //!                            stored in the keystore as spendable
+// NOLINTNEXTLINE(misc-no-recursion)
 IsMineResult IsMineInner(const LegacyScriptPubKeyMan& keystore, const CScript& scriptPubKey, IsMineSigVersion sigversion, bool recurse_scripthash=true)
 {
     IsMineResult ret = IsMineResult::NO;

Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,7 @@ CMerkleBlock::CMerkleBlock(const CBlock& block, CBloomFilter* filter, const std:`
`54`	`54`	`txn = CPartialMerkleTree(vHashes, vMatch);`
`55`	`55`	`}`
`56`	`56`
	`57`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`57`	`58`	`uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::vector<uint256> &vTxid) {`
`58`	`59`	`//we can never have zero txs in a merkle block, we always need the coinbase tx`
`59`	`60`	`//if we do not have this assert, we can hit a memory access violation when indexing into vTxid`
`@@ -74,6 +75,7 @@ uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::ve`
`74`	`75`	`}`
`75`	`76`	`}`
`76`	`77`
	`78`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`77`	`79`	`void CPartialMerkleTree::TraverseAndBuild(int height, unsigned int pos, const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch) {`
`78`	`80`	`// determine whether this node is the parent of at least one matched txid`
`79`	`81`	`bool fParentOfMatch = false;`
`@@ -92,6 +94,7 @@ void CPartialMerkleTree::TraverseAndBuild(int height, unsigned int pos, const st`
`92`	`94`	`}`
`93`	`95`	`}`
`94`	`96`
	`97`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`95`	`98`	`uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, unsigned int &nBitsUsed, unsigned int &nHashUsed, std::vector<uint256> &vMatch, std::vector<unsigned int> &vnIndex) {`
`96`	`99`	`if (nBitsUsed >= vBits.size()) {`
`97`	`100`	`// overflowed the bits array - failure`
Original file line number	Diff line number	Diff line change
`@@ -406,6 +406,7 @@ class NodeImpl : public Node`
`406`	`406`	`NodeContext* m_context{nullptr};`
`407`	`407`	`};`
`408`	`408`
	`409`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`409`	`410`	`bool FillBlock(const CBlockIndex* index, const FoundBlock& block, UniqueLock<RecursiveMutex>& lock, const CChain& active, const BlockManager& blockman)`
`410`	`411`	`{`
`411`	`412`	`if (!index) return false;`
Original file line number	Diff line number	Diff line change
`@@ -396,6 +396,7 @@ bool OptionsModel::setData(const QModelIndex & index, const QVariant & value, in`
`396`	`396`	`return successful;`
`397`	`397`	`}`
`398`	`398`
	`399`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`399`	`400`	`QVariant OptionsModel::getOption(OptionID option, const std::string& suffix) const`
`400`	`401`	`{`
`401`	`402`	`auto setting = [&]{ return node().getPersistentSetting(SettingName(option) + suffix); };`
`@@ -508,6 +509,7 @@ QFont OptionsModel::getFontForMoney() const`
`508`	`509`	`return getFontForChoice(m_font_money);`
`509`	`510`	`}`
`510`	`511`
	`512`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`511`	`513`	`bool OptionsModel::setOption(OptionID option, const QVariant& value, const std::string& suffix)`
`512`	`514`	`{`
`513`	`515`	`auto changed = [&] { return value.isValid() && value != getOption(option, suffix); };`
Original file line number	Diff line number	Diff line change
`@@ -414,6 +414,7 @@ struct Sections {`
`414`	`414`	`/**`
`415`	`415`	`* Recursive helper to translate an RPCArg into sections`
`416`	`416`	`*/`
	`417`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`417`	`418`	`void Push(const RPCArg& arg, const size_t current_indent = 5, const OuterType outer_type = OuterType::NONE)`
`418`	`419`	`{`
`419`	`420`	`const auto indent = std::string(current_indent, ' ');`
`@@ -953,6 +954,7 @@ std::string RPCArg::ToDescriptionString(bool is_named_arg) const`
`953`	`954`	`return ret;`
`954`	`955`	`}`
`955`	`956`
	`957`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`956`	`958`	`void RPCResult::ToSections(Sections& sections, const OuterType outer_type, const int current_indent) const`
`957`	`959`	`{`
`958`	`960`	`// Indentation`
`@@ -1086,6 +1088,7 @@ static std::optional<UniValue::VType> ExpectedType(RPCResult::Type type)`
`1086`	`1088`	`NONFATAL_UNREACHABLE();`
`1087`	`1089`	`}`
`1088`	`1090`
	`1091`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`1089`	`1092`	`UniValue RPCResult::MatchesType(const UniValue& result) const`
`1090`	`1093`	`{`
`1091`	`1094`	`if (m_skip_type_check) {`
`@@ -1164,6 +1167,7 @@ void RPCResult::CheckInnerDoc() const`
`1164`	`1167`	`CHECK_NONFATAL(inner_needed != m_inner.empty());`
`1165`	`1168`	`}`
`1166`	`1169`
	`1170`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`1167`	`1171`	`std::string RPCArg::ToStringObj(const bool oneline) const`
`1168`	`1172`	`{`
`1169`	`1173`	`std::string res;`
`@@ -1202,6 +1206,7 @@ std::string RPCArg::ToStringObj(const bool oneline) const`
`1202`	`1206`	`NONFATAL_UNREACHABLE();`
`1203`	`1207`	`}`
`1204`	`1208`
	`1209`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`1205`	`1210`	`std::string RPCArg::ToString(const bool oneline) const`
`1206`	`1211`	`{`
`1207`	`1212`	`if (oneline && !m_opts.oneline_description.empty()) {`
`@@ -1228,6 +1233,7 @@ std::string RPCArg::ToString(const bool oneline) const`
`1228`	`1233`	`case Type::OBJ:`
`1229`	`1234`	`case Type::OBJ_NAMED_PARAMS:`
`1230`	`1235`	`case Type::OBJ_USER_KEYS: {`
	`1236`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`1231`	`1237`	`const std::string res = Join(m_inner, ",", [&](const RPCArg& i) { return i.ToStringObj(oneline); });`
`1232`	`1238`	`if (m_type == Type::OBJ) {`
`1233`	`1239`	`return "{" + res + "}";`
Original file line number	Diff line number	Diff line change
`@@ -599,6 +599,7 @@ class DescriptorImpl : public Descriptor`
`599`	`599`	`COMPAT, // string calculation that mustn't change over time to stay compatible with previous software versions`
`600`	`600`	`};`
`601`	`601`
	`602`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`602`	`603`	`bool IsSolvable() const override`
`603`	`604`	`{`
`604`	`605`	`for (const auto& arg : m_subdescriptor_args) {`
`@@ -607,6 +608,7 @@ class DescriptorImpl : public Descriptor`
`607`	`608`	`return true;`
`608`	`609`	`}`
`609`	`610`
	`611`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`610`	`612`	`bool IsRange() const final`
`611`	`613`	`{`
`612`	`614`	`for (const auto& pubkey : m_pubkey_args) {`
`@@ -618,6 +620,7 @@ class DescriptorImpl : public Descriptor`
`618`	`620`	`return false;`
`619`	`621`	`}`
`620`	`622`
	`623`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`621`	`624`	`virtual bool ToStringSubScriptHelper(const SigningProvider* arg, std::string& ret, const StringType type, const DescriptorCache* cache = nullptr) const`
`622`	`625`	`{`
`623`	`626`	`size_t pos = 0;`
`@@ -630,6 +633,7 @@ class DescriptorImpl : public Descriptor`
`630`	`633`	`return true;`
`631`	`634`	`}`
`632`	`635`
	`636`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`633`	`637`	`virtual bool ToStringHelper(const SigningProvider* arg, std::string& out, const StringType type, const DescriptorCache* cache = nullptr) const`
`634`	`638`	`{`
`635`	`639`	`std::string extra = ToStringExtra();`
`@@ -682,6 +686,7 @@ class DescriptorImpl : public Descriptor`
`682`	`686`	`return ret;`
`683`	`687`	`}`
`684`	`688`
	`689`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`685`	`690`	`bool ExpandHelper(int pos, const SigningProvider& arg, const DescriptorCache* read_cache, std::vector<CScript>& output_scripts, FlatSigningProvider& out, DescriptorCache* write_cache) const`
`686`	`691`	`{`
`687`	`692`	`std::vector<std::pair<CPubKey, KeyOriginInfo>> entries;`
`@@ -723,6 +728,7 @@ class DescriptorImpl : public Descriptor`
`723`	`728`	`return ExpandHelper(pos, DUMMY_SIGNING_PROVIDER, &read_cache, output_scripts, out, nullptr);`
`724`	`729`	`}`
`725`	`730`
	`731`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`726`	`732`	`void ExpandPrivate(int pos, const SigningProvider& provider, FlatSigningProvider& out) const final`
`727`	`733`	`{`
`728`	`734`	`for (const auto& p : m_pubkey_args) {`
`@@ -750,6 +756,7 @@ class DescriptorImpl : public Descriptor`
`750`	`756`
`751`	`757`	`std::optional<int64_t> MaxSatisfactionElems() const override { return {}; }`
`752`	`758`
	`759`	`+ // NOLINTNEXTLINE(misc-no-recursion)`
`753`	`760`	`void GetPubKeys(std::set<CPubKey>& pubkeys, std::set<CExtPubKey>& ext_pubs) const override`
`754`	`761`	`{`
`755`	`762`	`for (const auto& p : m_pubkey_args) {`
`@@ -1579,6 +1586,7 @@ struct KeyParser {`
`1579`	`1586`	`};`
`1580`	`1587`
`1581`	`1588`	`/** Parse a script in a particular context. */`
	`1589`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`1582`	`1590`	`std::unique_ptr<DescriptorImpl> ParseScript(uint32_t& key_exp_index, Span<const char>& sp, ParseScriptContext ctx, FlatSigningProvider& out, std::string& error)`
`1583`	`1591`	`{`
`1584`	`1592`	`using namespace spanparsing;`
`@@ -1886,6 +1894,7 @@ std::unique_ptr<DescriptorImpl> InferMultiA(const CScript& script, ParseScriptCo`
`1886`	`1894`	`return std::make_unique<MultiADescriptor>(match->first, std::move(keys));`
`1887`	`1895`	`}`
`1888`	`1896`
	`1897`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`1889`	`1898`	`std::unique_ptr<DescriptorImpl> InferScript(const CScript& script, ParseScriptContext ctx, const SigningProvider& provider)`
`1890`	`1899`	`{`
`1891`	`1900`	`if (ctx == ParseScriptContext::P2TR && script.size() == 34 && script[0] == 32 && script[33] == OP_CHECKSIG) {`
Original file line number	Diff line number	Diff line change
`@@ -127,6 +127,7 @@ std::shared_ptr<const CBlock> MinerTestingSetup::BadBlock(const uint256& prev_ha`
`127`	`127`	`return ret;`
`128`	`128`	`}`
`129`	`129`
	`130`	`+// NOLINTNEXTLINE(misc-no-recursion)`
`130`	`131`	`void MinerTestingSetup::BuildChain(const uint256& root, int height, const unsigned int invalid_rate, const unsigned int branch_rate, const unsigned int max_size, std::vector<std::shared_ptr<const CBlock>>& blocks)`
`131`	`132`	`{`
`132`	`133`	`if (height <= 0 \|\| blocks.size() >= max_size) return;`