Replace MakeSpan helper with Span deduction guide

sipa · sipa · commit 568dd2f83900 · 2021-11-29T17:58:53.000-05:00
diff --git a/src/base58.cpp b/src/base58.cpp
@@ -149,7 +149,7 @@ std::string EncodeBase58Check(Span<const unsigned char> input)
         return false;
     }
     // re-calculate the checksum, ensure it matches the included 4-byte checksum
-    uint256 hash = Hash(MakeSpan(vchRet).first(vchRet.size() - 4));
+    uint256 hash = Hash(Span{vchRet}.first(vchRet.size() - 4));
     if (memcmp(&hash, &vchRet[vchRet.size() - 4], 4) != 0) {
         vchRet.clear();
         return false;
diff --git a/src/compressor.h b/src/compressor.h
@@ -65,12 +65,12 @@ struct ScriptCompression
     void Ser(Stream &s, const CScript& script) {
         CompressedScript compr;
         if (CompressScript(script, compr)) {
-            s << MakeSpan(compr);
+            s << Span{compr};
             return;
         }
         unsigned int nSize = script.size() + nSpecialScripts;
         s << VARINT(nSize);
-        s << MakeSpan(script);
+        s << Span{script};
     }
 
     template<typename Stream>
@@ -79,7 +79,7 @@ struct ScriptCompression
         s >> VARINT(nSize);
         if (nSize < nSpecialScripts) {
             CompressedScript vch(GetSpecialScriptSize(nSize), 0x00);
-            s >> MakeSpan(vch);
+            s >> Span{vch};
             DecompressScript(script, nSize, vch);
             return;
         }
@@ -90,7 +90,7 @@ struct ScriptCompression
             s.ignore(nSize);
         } else {
             script.resize(nSize);
-            s >> MakeSpan(script);
+            s >> Span{script};
         }
     }
 };
diff --git a/src/net_processing.cpp b/src/net_processing.cpp
@@ -1815,7 +1815,7 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&
         if (!ReadRawBlockFromDisk(block_data, pindex, m_chainparams.MessageStart())) {
             assert(!"cannot load block from disk");
         }
-        m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::BLOCK, MakeSpan(block_data)));
+        m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::BLOCK, Span{block_data}));
         // Don't set pblock as we've sent the block
     } else {
         // Send block from disk
diff --git a/src/netaddress.cpp b/src/netaddress.cpp
@@ -196,7 +196,7 @@ static void Checksum(Span<const uint8_t> addr_pubkey, uint8_t (&checksum)[CHECKS
 
     SHA3_256 hasher;
 
-    hasher.Write(MakeSpan(prefix).first(prefix_len));
+    hasher.Write(Span{prefix}.first(prefix_len));
     hasher.Write(addr_pubkey);
     hasher.Write(VERSION);
 
@@ -693,13 +693,13 @@ uint32_t CNetAddr::GetLinkedIPv4() const
         return ReadBE32(m_addr.data());
     } else if (IsRFC6052() || IsRFC6145()) {
         // mapped IPv4, SIIT translated IPv4: the IPv4 address is the last 4 bytes of the address
-        return ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
+        return ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
     } else if (IsRFC3964()) {
         // 6to4 tunneled IPv4: the IPv4 address is in bytes 2-6
-        return ReadBE32(MakeSpan(m_addr).subspan(2, ADDR_IPV4_SIZE).data());
+        return ReadBE32(Span{m_addr}.subspan(2, ADDR_IPV4_SIZE).data());
     } else if (IsRFC4380()) {
         // Teredo tunneled IPv4: the IPv4 address is in the last 4 bytes of the address, but bitflipped
-        return ~ReadBE32(MakeSpan(m_addr).last(ADDR_IPV4_SIZE).data());
+        return ~ReadBE32(Span{m_addr}.last(ADDR_IPV4_SIZE).data());
     }
     assert(false);
 }
diff --git a/src/netaddress.h b/src/netaddress.h
@@ -433,7 +433,7 @@ class CNetAddr
 
         if (SetNetFromBIP155Network(bip155_net, address_size)) {
             m_addr.resize(address_size);
-            s >> MakeSpan(m_addr);
+            s >> Span{m_addr};
 
             if (m_net != NET_IPV6) {
                 return;
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
@@ -251,7 +251,7 @@ bool IsWitnessStandard(const CTransaction& tx, const CCoinsViewCache& mapInputs)
         // - No annexes
         if (witnessversion == 1 && witnessprogram.size() == WITNESS_V1_TAPROOT_SIZE && !p2sh) {
             // Taproot spend (non-P2SH-wrapped, version 1, witness program size 32; see BIP 341)
-            auto stack = MakeSpan(tx.vin[i].scriptWitness.stack);
+            Span stack{tx.vin[i].scriptWitness.stack};
             if (stack.size() >= 2 && !stack.back().empty() && stack.back()[0] == ANNEX_TAG) {
                 // Annexes are nonstandard as long as no semantics are defined for them.
                 return false;
diff --git a/src/psbt.h b/src/psbt.h
@@ -81,7 +81,7 @@ struct PSBTInput
         if (final_script_sig.empty() && final_script_witness.IsNull()) {
             // Write any partial signatures
             for (auto sig_pair : partial_sigs) {
-                SerializeToVector(s, PSBT_IN_PARTIAL_SIG, MakeSpan(sig_pair.second.first));
+                SerializeToVector(s, PSBT_IN_PARTIAL_SIG, Span{sig_pair.second.first});
                 s << sig_pair.second.second;
             }
 
diff --git a/src/pubkey.h b/src/pubkey.h
@@ -157,13 +157,13 @@ class CPubKey
     //! Get the KeyID of this public key (hash of its serialization)
     CKeyID GetID() const
     {
-        return CKeyID(Hash160(MakeSpan(vch).first(size())));
+        return CKeyID(Hash160(Span{vch}.first(size())));
     }
 
     //! Get the 256-bit hash of this public key.
     uint256 GetHash() const
     {
-        return Hash(MakeSpan(vch).first(size()));
+        return Hash(Span{vch}.first(size()));
     }
 
     /*
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
@@ -631,7 +631,7 @@ class DescriptorImpl : public Descriptor
             out.origins.emplace(entry.first.GetID(), std::make_pair<CPubKey, KeyOriginInfo>(CPubKey(entry.first), std::move(entry.second)));
         }
 
-        output_scripts = MakeScripts(pubkeys, MakeSpan(subscripts), out);
+        output_scripts = MakeScripts(pubkeys, Span{subscripts}, out);
         return true;
     }
 
@@ -974,10 +974,10 @@ std::unique_ptr<PubkeyProvider> ParsePubkeyInner(uint32_t key_exp_index, const S
     }
     KeyPath path;
     DeriveType type = DeriveType::NO;
-    if (split.back() == MakeSpan("*").first(1)) {
+    if (split.back() == Span{"*"}.first(1)) {
         split.pop_back();
         type = DeriveType::UNHARDENED;
-    } else if (split.back() == MakeSpan("*'").first(2) || split.back() == MakeSpan("*h").first(2)) {
+    } else if (split.back() == Span{"*'"}.first(2) || split.back() == Span{"*h"}.first(2)) {
         split.pop_back();
         type = DeriveType::HARDENED;
     }
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
@@ -167,7 +167,7 @@ static bool SignTaprootScript(const SigningProvider& provider, const BaseSignatu
 
     // <xonly pubkey> OP_CHECKSIG
     if (script.size() == 34 && script[33] == OP_CHECKSIG && script[0] == 0x20) {
-        XOnlyPubKey pubkey(MakeSpan(script).subspan(1, 32));
+        XOnlyPubKey pubkey{Span{script}.subspan(1, 32)};
         std::vector<unsigned char> sig;
         if (CreateTaprootScriptSig(creator, sigdata, provider, sig, pubkey, leaf_hash, sigversion)) {
             result = Vector(std::move(sig));
diff --git a/src/script/sign.h b/src/script/sign.h
@@ -149,7 +149,7 @@ void SerializeHDKeypaths(Stream& s, const std::map<CPubKey, KeyOriginInfo>& hd_k
         if (!keypath_pair.first.IsValid()) {
             throw std::ios_base::failure("Invalid CPubKey being serialized");
         }
-        SerializeToVector(s, type, MakeSpan(keypath_pair.first));
+        SerializeToVector(s, type, Span{keypath_pair.first});
         WriteCompactSize(s, (keypath_pair.second.path.size() + 1) * sizeof(uint32_t));
         s << keypath_pair.second.fingerprint;
         for (const auto& path : keypath_pair.second.path) {
diff --git a/src/span.h b/src/span.h
@@ -222,13 +222,15 @@ class Span
     template <typename O> friend class Span;
 };
 
-// MakeSpan helps constructing a Span of the right type automatically.
-/** MakeSpan for arrays: */
-template <typename A, int N> Span<A> constexpr MakeSpan(A (&a)[N]) { return Span<A>(a, N); }
-/** MakeSpan for temporaries / rvalue references, only supporting const output. */
-template <typename V> constexpr auto MakeSpan(V&& v SPAN_ATTR_LIFETIMEBOUND) -> typename std::enable_if<!std::is_lvalue_reference<V>::value, Span<const typename std::remove_pointer<decltype(v.data())>::type>>::type { return std::forward<V>(v); }
-/** MakeSpan for (lvalue) references, supporting mutable output. */
-template <typename V> constexpr auto MakeSpan(V& v SPAN_ATTR_LIFETIMEBOUND) -> Span<typename std::remove_pointer<decltype(v.data())>::type> { return v; }
+// Deduction guides for Span
+// For the pointer/size based and iterator based constructor:
+template <typename T, typename EndOrSize> Span(T*, EndOrSize) -> Span<T>;
+// For the array constructor:
+template <typename T, std::size_t N> Span(T (&)[N]) -> Span<T>;
+// For the temporaries/rvalue references constructor, only supporting const output.
+template <typename T> Span(T&&) -> Span<std::enable_if_t<!std::is_lvalue_reference_v<T>, const std::remove_pointer_t<decltype(std::declval<T&&>().data())>>>;
+// For (lvalue) references, supporting mutable output.
+template <typename T> Span(T&) -> Span<std::remove_pointer_t<decltype(std::declval<T&>().data())>>;
 
 /** Pop the last element off a span, and return a reference to that element. */
 template <typename T>
@@ -274,7 +276,7 @@ inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_c
 // Helper function to safely convert a Span to a Span<[const] unsigned char>.
 template <typename T> constexpr auto UCharSpanCast(Span<T> s) -> Span<typename std::remove_pointer<decltype(UCharCast(s.data()))>::type> { return {UCharCast(s.data()), s.size()}; }
 
-/** Like MakeSpan, but for (const) unsigned char member types only. Only works for (un)signed char containers. */
-template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(MakeSpan(std::forward<V>(v)))) { return UCharSpanCast(MakeSpan(std::forward<V>(v))); }
+/** Like the Span constructor, but for (const) unsigned char member types only. Only works for (un)signed char containers. */
+template <typename V> constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward<V>(v)})) { return UCharSpanCast(Span{std::forward<V>(v)}); }
 
 #endif // BITCOIN_SPAN_H
diff --git a/src/test/crypto_tests.cpp b/src/test/crypto_tests.cpp
@@ -770,8 +770,8 @@ static void TestSHA3_256(const std::string& input, const std::string& output)
     int s1 = InsecureRandRange(in_bytes.size() + 1);
     int s2 = InsecureRandRange(in_bytes.size() + 1 - s1);
     int s3 = in_bytes.size() - s1 - s2;
-    sha.Write(MakeSpan(in_bytes).first(s1)).Write(MakeSpan(in_bytes).subspan(s1, s2));
-    sha.Write(MakeSpan(in_bytes).last(s3)).Finalize(out);
+    sha.Write(Span{in_bytes}.first(s1)).Write(Span{in_bytes}.subspan(s1, s2));
+    sha.Write(Span{in_bytes}.last(s3)).Finalize(out);
     BOOST_CHECK(std::equal(std::begin(out_bytes), std::end(out_bytes), out));
 }
 
diff --git a/src/test/net_tests.cpp b/src/test/net_tests.cpp
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp

Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ std::string EncodeBase58Check(Span<const unsigned char> input)`
`149`	`149`	`return false;`
`150`	`150`	`}`
`151`	`151`	`// re-calculate the checksum, ensure it matches the included 4-byte checksum`
`152`		`- uint256 hash = Hash(MakeSpan(vchRet).first(vchRet.size() - 4));`
	`152`	`+ uint256 hash = Hash(Span{vchRet}.first(vchRet.size() - 4));`
`153`	`153`	`if (memcmp(&hash, &vchRet[vchRet.size() - 4], 4) != 0) {`
`154`	`154`	`vchRet.clear();`
`155`	`155`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -1815,7 +1815,7 @@ void PeerManagerImpl::ProcessGetBlockData(CNode& pfrom, Peer& peer, const CInv&`
`1815`	`1815`	`if (!ReadRawBlockFromDisk(block_data, pindex, m_chainparams.MessageStart())) {`
`1816`	`1816`	`assert(!"cannot load block from disk");`
`1817`	`1817`	`}`
`1818`		`- m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::BLOCK, MakeSpan(block_data)));`
	`1818`	`+ m_connman.PushMessage(&pfrom, msgMaker.Make(NetMsgType::BLOCK, Span{block_data}));`
`1819`	`1819`	`// Don't set pblock as we've sent the block`
`1820`	`1820`	`} else {`
`1821`	`1821`	`// Send block from disk`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ struct PSBTInput`
`81`	`81`	`if (final_script_sig.empty() && final_script_witness.IsNull()) {`
`82`	`82`	`// Write any partial signatures`
`83`	`83`	`for (auto sig_pair : partial_sigs) {`
`84`		`- SerializeToVector(s, PSBT_IN_PARTIAL_SIG, MakeSpan(sig_pair.second.first));`
	`84`	`+ SerializeToVector(s, PSBT_IN_PARTIAL_SIG, Span{sig_pair.second.first});`
`85`	`85`	`s << sig_pair.second.second;`
`86`	`86`	`}`
`87`	`87`
Original file line number	Diff line number	Diff line change
`@@ -157,13 +157,13 @@ class CPubKey`
`157`	`157`	`//! Get the KeyID of this public key (hash of its serialization)`
`158`	`158`	`CKeyID GetID() const`
`159`	`159`	`{`
`160`		`- return CKeyID(Hash160(MakeSpan(vch).first(size())));`
	`160`	`+ return CKeyID(Hash160(Span{vch}.first(size())));`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`//! Get the 256-bit hash of this public key.`
`164`	`164`	`uint256 GetHash() const`
`165`	`165`	`{`
`166`		`- return Hash(MakeSpan(vch).first(size()));`
	`166`	`+ return Hash(Span{vch}.first(size()));`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`/*`
Original file line number	Diff line number	Diff line change
`@@ -631,7 +631,7 @@ class DescriptorImpl : public Descriptor`
`631`	`631`	`out.origins.emplace(entry.first.GetID(), std::make_pair<CPubKey, KeyOriginInfo>(CPubKey(entry.first), std::move(entry.second)));`
`632`	`632`	`}`
`633`	`633`
`634`		`- output_scripts = MakeScripts(pubkeys, MakeSpan(subscripts), out);`
	`634`	`+ output_scripts = MakeScripts(pubkeys, Span{subscripts}, out);`
`635`	`635`	`return true;`
`636`	`636`	`}`
`637`	`637`
`@@ -974,10 +974,10 @@ std::unique_ptr<PubkeyProvider> ParsePubkeyInner(uint32_t key_exp_index, const S`
`974`	`974`	`}`
`975`	`975`	`KeyPath path;`
`976`	`976`	`DeriveType type = DeriveType::NO;`
`977`		`- if (split.back() == MakeSpan("*").first(1)) {`
	`977`	`+ if (split.back() == Span{"*"}.first(1)) {`
`978`	`978`	`split.pop_back();`
`979`	`979`	`type = DeriveType::UNHARDENED;`
`980`		`- } else if (split.back() == MakeSpan("'").first(2) \|\| split.back() == MakeSpan("h").first(2)) {`
	`980`	`+ } else if (split.back() == Span{"'"}.first(2) \|\| split.back() == Span{"h"}.first(2)) {`
`981`	`981`	`split.pop_back();`
`982`	`982`	`type = DeriveType::HARDENED;`
`983`	`983`	`}`