Merge bitcoin/bitcoin#26642: clang-tidy: Add more performance-* checks and related fixes

03ec5b6f9c clang-tidy: Exclude `performance-*` checks rather including them (Hennadii Stepanov)
2400437230 clang-tidy: Add `performance-type-promotion-in-math-fn` check (Hennadii Stepanov)
7e975e6cf8 clang-tidy: Add `performance-inefficient-vector-operation` check (Hennadii Stepanov)
516b75f66e clang-tidy: Add `performance-faster-string-find` check (Hennadii Stepanov)

Pull request description:

ACKs for top commit:
  martinus:
    ACK 03ec5b6f9c
  TheCharlatan:
    re-ACK [03ec5b6](03ec5b6f9c)

Tree-SHA512: 2dfa52f9131da88826f32583bfd534a56a998477db9804b7333c0e7ac0b6b36141009755c7163b9f95d0ecbf5c2cb63f8a69ce4b114bb83423faed21b50cec67

src/.clang-tidy

@@ -5,10 +5,11 @@ bugprone-use-after-move,
 misc-unused-using-decls,
 modernize-use-default-member-init,
 modernize-use-nullptr,
-performance-for-range-copy,
-performance-move-const-arg,
-performance-no-automatic-move,
-performance-unnecessary-copy-initialization,
+performance-*,
+-performance-inefficient-string-concatenation,
+-performance-no-int-to-ptr,
+-performance-noexcept-move-constructor,
+-performance-unnecessary-value-param,
 readability-const-return-type,
 readability-redundant-declaration,
 readability-redundant-string-init,

src/bench/lockedpool.cpp

@@ -17,9 +17,7 @@ static void BenchLockedPool(benchmark::Bench& bench)
     const size_t synth_size = 1024*1024;
     Arena b(synth_base, synth_size, 16);
 
-    std::vector<void*> addr;
-    for (int x=0; x<ASIZE; ++x)
-        addr.push_back(nullptr);
+    std::vector<void*> addr{ASIZE, nullptr};
     uint32_t s = 0x12345678;
     bench.run([&] {
         int idx = s & (addr.size() - 1);

src/bench/wallet_create_tx.cpp

@@ -146,6 +146,7 @@ static void AvailableCoins(benchmark::Bench& bench, const std::vector<OutputType
 
     // Generate destinations
     std::vector<CScript> dest_wallet;
+    dest_wallet.reserve(output_type.size());
     for (auto type : output_type) {
         dest_wallet.emplace_back(GetScriptForDestination(getNewDestination(wallet, type)));
     }

src/bitcoin-cli.cpp

@@ -1032,6 +1032,7 @@ static void ParseGetInfoResult(UniValue& result)
     }
 
     std::vector<std::string> formatted_proxies;
+    formatted_proxies.reserve(ordered_proxies.size());
     for (const std::string& proxy : ordered_proxies) {
         formatted_proxies.emplace_back(strprintf("%s (%s)", proxy, Join(proxy_networks.find(proxy)->second, ", ")));
     }

src/bitcoin-util.cpp

@@ -127,6 +127,7 @@ static int Grind(const std::vector<std::string>& args, std::string& strPrint)
 
     std::vector<std::thread> threads;
     int n_tasks = std::max(1u, std::thread::hardware_concurrency());
+    threads.reserve(n_tasks);
     for (int i = 0; i < n_tasks; ++i) {
         threads.emplace_back(grind_task, nBits, header, i, n_tasks, std::ref(found), std::ref(proposed_nonce));
     }

src/node/interfaces.cpp

@@ -241,6 +241,7 @@ public:
         if (command == "") return {};
         ExternalSigner::Enumerate(command, signers, Params().NetworkIDString());
         std::vector<std::unique_ptr<interfaces::ExternalSigner>> result;
+        result.reserve(signers.size());
         for (auto& signer : signers) {
             result.emplace_back(std::make_unique<ExternalSignerImpl>(std::move(signer)));
         }

src/qt/trafficgraphwidget.cpp

@@ -68,8 +68,8 @@ void TrafficGraphWidget::paintEvent(QPaintEvent *)
     painter.drawLine(XMARGIN, YMARGIN + h, width() - XMARGIN, YMARGIN + h);
 
     // decide what order of magnitude we are
-    int base = floor(log10(fMax));
-    float val = pow(10.0f, base);
+    int base = std::floor(std::log10(fMax));
+    float val = std::pow(10.0f, base);
 
     const QString units = tr("kB/s");
     const float yMarginText = 2.0;

src/rpc/server.cpp

@@ -83,6 +83,7 @@ std::string CRPCTable::help(const std::string& strCommand, const JSONRPCRequest&
     std::string category;
     std::set<intptr_t> setDone;
     std::vector<std::pair<std::string, const CRPCCommand*> > vCommands;
+    vCommands.reserve(mapCommands.size());
 
     for (const auto& entry : mapCommands)
         vCommands.push_back(make_pair(entry.second.front()->category + entry.first, entry.second.front()));
@@ -513,6 +514,7 @@ static bool ExecuteCommand(const CRPCCommand& command, const JSONRPCRequest& req
 std::vector<std::string> CRPCTable::listCommands() const
 {
     std::vector<std::string> commandList;
+    commandList.reserve(mapCommands.size());
     for (const auto& i : mapCommands) commandList.emplace_back(i.first);
     return commandList;
 }

src/rpc/util.cpp

@@ -608,6 +608,7 @@ bool RPCHelpMan::IsValidNumArgs(size_t num_args) const
 std::vector<std::string> RPCHelpMan::GetArgNames() const
 {
     std::vector<std::string> ret;
+    ret.reserve(m_args.size());
     for (const auto& arg : m_args) {
         ret.emplace_back(arg.m_names);
     }
@@ -732,12 +733,12 @@ UniValue RPCArg::MatchesType(const UniValue& request) const
 
 std::string RPCArg::GetFirstName() const
 {
-    return m_names.substr(0, m_names.find("|"));
+    return m_names.substr(0, m_names.find('|'));
 }
 
 std::string RPCArg::GetName() const
 {
-    CHECK_NONFATAL(std::string::npos == m_names.find("|"));
+    CHECK_NONFATAL(std::string::npos == m_names.find('|'));
     return m_names;
 }
 

src/script/descriptor.cpp

@@ -830,6 +830,7 @@ protected:
     std::vector<CScript> MakeScripts(const std::vector<CPubKey>& keys, Span<const CScript>, FlatSigningProvider&) const override {
         CScript ret;
         std::vector<XOnlyPubKey> xkeys;
+        xkeys.reserve(keys.size());
         for (const auto& key : keys) xkeys.emplace_back(key);
         if (m_sorted) std::sort(xkeys.begin(), xkeys.end());
         ret << ToByteVector(xkeys[0]) << OP_CHECKSIG;

src/test/allocator_tests.cpp

@@ -77,6 +77,7 @@ BOOST_AUTO_TEST_CASE(arena_tests)
     b.walk();
 #endif
     // Sweeping allocate all memory
+    addr.reserve(2048);
     for (int x=0; x<1024; ++x)
         addr.push_back(b.alloc(1024));
     BOOST_CHECK(b.stats().free == 0);

src/test/fuzz/tx_pool.cpp

@@ -316,6 +316,7 @@ FUZZ_TARGET_INIT(tx_pool, initialize_tx_pool)
     MockTime(fuzzed_data_provider, chainstate);
 
     std::vector<uint256> txids;
+    txids.reserve(g_outpoints_coinbase_init_mature.size());
     for (const auto& outpoint : g_outpoints_coinbase_init_mature) {
         txids.push_back(outpoint.hash);
     }

src/test/getarg_tests.cpp

@@ -29,6 +29,7 @@ void ResetArgs(ArgsManager& local_args, const std::string& strArg)
 
     // Convert to char*:
     std::vector<const char*> vecChar;
+    vecChar.reserve(vecArg.size());
     for (const std::string& s : vecArg)
         vecChar.push_back(s.c_str());
 

src/test/policyestimator_tests.cpp

@@ -24,6 +24,7 @@ BOOST_AUTO_TEST_CASE(BlockPolicyEstimates)
     CAmount basefee(2000);
     CAmount deltaFee(100);
     std::vector<CAmount> feeV;
+    feeV.reserve(10);
 
     // Populate vectors of increasing fees
     for (int j = 0; j < 10; j++) {

src/test/scheduler_tests.cpp

@@ -71,6 +71,7 @@ BOOST_AUTO_TEST_CASE(manythreads)
 
     // As soon as these are created they will start running and servicing the queue
     std::vector<std::thread> microThreads;
+    microThreads.reserve(10);
     for (int i = 0; i < 5; i++)
         microThreads.emplace_back(std::bind(&CScheduler::serviceQueue, &microTasks));
 
@@ -136,6 +137,7 @@ BOOST_AUTO_TEST_CASE(singlethreadedscheduler_ordered)
     // the extra threads should effectively be doing nothing
     // if they don't we'll get out of order behaviour
     std::vector<std::thread> threads;
+    threads.reserve(5);
     for (int i = 0; i < 5; ++i) {
         threads.emplace_back([&] { scheduler.serviceQueue(); });
     }

src/test/script_p2sh_tests.cpp

@@ -156,6 +156,7 @@ BOOST_AUTO_TEST_CASE(set)
     FillableSigningProvider keystore;
     CKey key[4];
     std::vector<CPubKey> keys;
+    keys.reserve(4);
     for (int i = 0; i < 4; i++)
     {
         key[i].MakeNewKey(true);
@@ -270,12 +271,13 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     CCoinsViewCache coins(&coinsDummy);
     FillableSigningProvider keystore;
     CKey key[6];
-    std::vector<CPubKey> keys;
     for (int i = 0; i < 6; i++)
     {
         key[i].MakeNewKey(true);
         BOOST_CHECK(keystore.AddKey(key[i]));
     }
+    std::vector<CPubKey> keys;
+    keys.reserve(3);
     for (int i = 0; i < 3; i++)
         keys.push_back(key[i].GetPubKey());
 

src/test/txrequest_tests.cpp

@@ -386,6 +386,7 @@ void BuildBigPriorityTest(Scenario& scenario, int peers)
     }
     // Make a list of all peers, in order of intended request order (concatenation of pref_peers and npref_peers).
     std::vector<NodeId> request_order;
+    request_order.reserve(num_pref + num_npref);
     for (int i = 0; i < num_pref; ++i) request_order.push_back(pref_peers[i]);
     for (int i = 0; i < num_npref; ++i) request_order.push_back(npref_peers[i]);
 

src/test/util/net.cpp

@@ -84,6 +84,7 @@ bool ConnmanTestMsg::ReceiveMsgFrom(CNode& node, CSerializedNetMsg& ser_msg) con
 std::vector<NodeEvictionCandidate> GetRandomNodeEvictionCandidates(int n_candidates, FastRandomContext& random_context)
 {
     std::vector<NodeEvictionCandidate> candidates;
+    candidates.reserve(n_candidates);
     for (int id = 0; id < n_candidates; ++id) {
         candidates.push_back({
             /*id=*/id,

src/test/util_threadnames_tests.cpp

@@ -38,6 +38,7 @@ std::set<std::string> RenameEnMasse(int num_threads)
         names.insert(util::ThreadGetInternalName());
     };
 
+    threads.reserve(num_threads);
     for (int i = 0; i < num_threads; ++i) {
         threads.push_back(std::thread(RenameThisThread, i));
     }

src/test/validation_block_tests.cpp

@@ -174,6 +174,7 @@ BOOST_AUTO_TEST_CASE(processnewblock_signals_ordering)
     // this will create parallelism and randomness inside validation - the ValidationInterface
     // will subscribe to events generated during block validation and assert on ordering invariance
     std::vector<std::thread> threads;
+    threads.reserve(10);
     for (int i = 0; i < 10; i++) {
         threads.emplace_back([&]() {
             bool ignored;

src/util/bip32.cpp

@@ -25,7 +25,7 @@ bool ParseHDKeypath(const std::string& keypath_str, std::vector<uint32_t>& keypa
         }
         // Finds whether it is hardened
         uint32_t path = 0;
-        size_t pos = item.find("'");
+        size_t pos = item.find('\'');
         if (pos != std::string::npos) {
             // The hardened tick can only be in the last index of the string
             if (pos != item.size() - 1) {

src/wallet/bdb.cpp

@@ -432,6 +432,7 @@ void BerkeleyEnvironment::ReloadDbEnv()
     });
 
     std::vector<fs::path> filenames;
+    filenames.reserve(m_databases.size());
     for (const auto& it : m_databases) {
         filenames.push_back(it.first);
     }

src/wallet/rpc/backup.cpp

@@ -752,6 +752,7 @@ RPCHelpMan dumpwallet()
 
     // sort time/key pairs
     std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
+    vKeyBirth.reserve(mapKeyBirth.size());
     for (const auto& entry : mapKeyBirth) {
         vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
     }

src/wallet/scriptpubkeyman.cpp

@@ -1507,6 +1507,7 @@ std::vector<CKeyID> GetAffectedKeys(const CScript& spk, const SigningProvider& p
     FlatSigningProvider out;
     InferDescriptor(spk, provider)->Expand(0, DUMMY_SIGNING_PROVIDER, dummy, out);
     std::vector<CKeyID> ret;
+    ret.reserve(out.pubkeys.size());
     for (const auto& entry : out.pubkeys) {
         ret.push_back(entry.first);
     }
@@ -2501,6 +2502,7 @@ TransactionError DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction&
         } else {
             // Maybe there are pubkeys listed that we can sign for
             std::vector<CPubKey> pubkeys;
+            pubkeys.reserve(input.hd_keypaths.size() + 2);
 
             // ECDSA Pubkeys
             for (const auto& [pk, _] : input.hd_keypaths) {

src/zmq/zmqpublishnotifier.cpp

@@ -96,7 +96,7 @@ static bool IsZMQAddressIPV6(const std::string &zmq_address)
 {
     const std::string tcp_prefix = "tcp://";
     const size_t tcp_index = zmq_address.rfind(tcp_prefix);
-    const size_t colon_index = zmq_address.rfind(":");
+    const size_t colon_index = zmq_address.rfind(':');
     if (tcp_index == 0 && colon_index != std::string::npos) {
         const std::string ip = zmq_address.substr(tcp_prefix.length(), colon_index - tcp_prefix.length());
         CNetAddr addr;