From be65b47645b234ee02208ccce36d944f53b3440a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= Date: Sat, 12 Aug 2023 01:04:12 +0300 Subject: [PATCH] all: update golang/x/ext and fix slice sorting fallout (#27909) The Go authors updated golang/x/ext to change the function signature of the slices sort method. It's an entire shitshow now because x/ext is not tagged, so everyone's codebase just picked a new version that some other dep depends on, causing our code to fail building. This PR updates the dep on our code too and does all the refactorings to follow upstream... --- accounts/keystore/account_cache.go | 4 +-- cmd/devp2p/dns_route53.go | 12 +++++-- cmd/devp2p/nodeset.go | 14 +++++--- common/types.go | 12 +++---- consensus/clique/snapshot.go | 2 +- consensus/clique/snapshot_test.go | 2 +- core/blockchain.go | 4 +-- core/rawdb/accessors_chain.go | 4 +-- core/rawdb/chain_iterator_test.go | 8 ++--- core/state/snapshot/difflayer.go | 4 +-- core/state/snapshot/iterator_fast.go | 18 +++++++---- eth/api_debug_test.go | 2 +- eth/gasprice/feehistory.go | 4 +-- eth/gasprice/gasprice.go | 6 ++-- eth/protocols/snap/sync_test.go | 16 +++++----- eth/tracers/api_test.go | 2 +- ethdb/dbtest/testsuite.go | 2 +- go.mod | 4 +-- go.sum | 8 ++--- internal/ethapi/api_test.go | 2 +- les/servingqueue.go | 10 ++++-- les/utils/limiter.go | 10 ++++-- metrics/writer.go | 8 ++--- metrics/writer_test.go | 2 +- p2p/discover/table_util_test.go | 8 ++--- p2p/discover/v4_lookup_test.go | 4 +-- p2p/discover/v5_udp_test.go | 4 +-- p2p/dnsdisc/tree.go | 4 +-- p2p/peer.go | 2 +- p2p/protocol.go | 15 ++++++--- p2p/server.go | 2 +- tests/fuzzers/rangeproof/rangeproof-fuzzer.go | 4 +-- tests/fuzzers/stacktrie/trie_fuzzer.go | 4 +-- trie/iterator_test.go | 4 +-- trie/proof_test.go | 32 +++++++++---------- trie/triedb/pathdb/history.go | 6 ++-- trie/triedb/pathdb/testutils.go | 2 +- trie/trienode/node.go | 6 ++-- 38 files changed, 144 insertions(+), 113 deletions(-) diff --git a/accounts/keystore/account_cache.go b/accounts/keystore/account_cache.go index a88b0fa5f3..4ed1439514 100644 --- a/accounts/keystore/account_cache.go +++ b/accounts/keystore/account_cache.go @@ -40,8 +40,8 @@ import ( const minReloadInterval = 2 * time.Second // byURL defines the sorting order for accounts. -func byURL(a, b accounts.Account) bool { - return a.URL.Cmp(b.URL) < 0 +func byURL(a, b accounts.Account) int { + return a.URL.Cmp(b.URL) } // AmbiguousAddrError is returned when attempting to unlock diff --git a/cmd/devp2p/dns_route53.go b/cmd/devp2p/dns_route53.go index eae6f70f58..21a32f9414 100644 --- a/cmd/devp2p/dns_route53.go +++ b/cmd/devp2p/dns_route53.go @@ -288,11 +288,17 @@ func makeDeletionChanges(records map[string]recordSet, keep map[string]string) [ // sortChanges ensures DNS changes are in leaf-added -> root-changed -> leaf-deleted order. func sortChanges(changes []types.Change) { score := map[string]int{"CREATE": 1, "UPSERT": 2, "DELETE": 3} - slices.SortFunc(changes, func(a, b types.Change) bool { + slices.SortFunc(changes, func(a, b types.Change) int { if a.Action == b.Action { - return *a.ResourceRecordSet.Name < *b.ResourceRecordSet.Name + return strings.Compare(*a.ResourceRecordSet.Name, *b.ResourceRecordSet.Name) } - return score[string(a.Action)] < score[string(b.Action)] + if score[string(a.Action)] < score[string(b.Action)] { + return -1 + } + if score[string(a.Action)] > score[string(b.Action)] { + return 1 + } + return 0 }) } diff --git a/cmd/devp2p/nodeset.go b/cmd/devp2p/nodeset.go index c040c1a908..7360dc5bcf 100644 --- a/cmd/devp2p/nodeset.go +++ b/cmd/devp2p/nodeset.go @@ -77,8 +77,8 @@ func (ns nodeSet) nodes() []*enode.Node { result = append(result, n.N) } // Sort by ID. - slices.SortFunc(result, func(a, b *enode.Node) bool { - return bytes.Compare(a.ID().Bytes(), b.ID().Bytes()) < 0 + slices.SortFunc(result, func(a, b *enode.Node) int { + return bytes.Compare(a.ID().Bytes(), b.ID().Bytes()) }) return result } @@ -103,8 +103,14 @@ func (ns nodeSet) topN(n int) nodeSet { for _, v := range ns { byscore = append(byscore, v) } - slices.SortFunc(byscore, func(a, b nodeJSON) bool { - return a.Score >= b.Score + slices.SortFunc(byscore, func(a, b nodeJSON) int { + if a.Score > b.Score { + return -1 + } + if a.Score < b.Score { + return 1 + } + return 0 }) result := make(nodeSet, n) for _, v := range byscore[:n] { diff --git a/common/types.go b/common/types.go index 93fb090454..bf74e43716 100644 --- a/common/types.go +++ b/common/types.go @@ -65,9 +65,9 @@ func BigToHash(b *big.Int) Hash { return BytesToHash(b.Bytes()) } // If b is larger than len(h), b will be cropped from the left. func HexToHash(s string) Hash { return BytesToHash(FromHex(s)) } -// Less compares two hashes. -func (h Hash) Less(other Hash) bool { - return bytes.Compare(h[:], other[:]) < 0 +// Cmp compares two hashes. +func (h Hash) Cmp(other Hash) int { + return bytes.Compare(h[:], other[:]) } // Bytes gets the byte representation of the underlying hash. @@ -231,9 +231,9 @@ func IsHexAddress(s string) bool { return len(s) == 2*AddressLength && isHex(s) } -// Less compares two addresses. -func (a Address) Less(other Address) bool { - return bytes.Compare(a[:], other[:]) < 0 +// Cmp compares two addresses. +func (a Address) Cmp(other Address) int { + return bytes.Compare(a[:], other[:]) } // Bytes gets the string representation of the underlying address. diff --git a/consensus/clique/snapshot.go b/consensus/clique/snapshot.go index 0f1b9f4b3a..a97115121b 100644 --- a/consensus/clique/snapshot.go +++ b/consensus/clique/snapshot.go @@ -308,7 +308,7 @@ func (s *Snapshot) signers() []common.Address { for sig := range s.Signers { sigs = append(sigs, sig) } - slices.SortFunc(sigs, common.Address.Less) + slices.SortFunc(sigs, common.Address.Cmp) return sigs } diff --git a/consensus/clique/snapshot_test.go b/consensus/clique/snapshot_test.go index f30900f274..26cebe008a 100644 --- a/consensus/clique/snapshot_test.go +++ b/consensus/clique/snapshot_test.go @@ -53,7 +53,7 @@ func (ap *testerAccountPool) checkpoint(header *types.Header, signers []string) for i, signer := range signers { auths[i] = ap.address(signer) } - slices.SortFunc(auths, common.Address.Less) + slices.SortFunc(auths, common.Address.Cmp) for i, auth := range auths { copy(header.Extra[extraVanity+i*common.AddressLength:], auth.Bytes()) } diff --git a/core/blockchain.go b/core/blockchain.go index 65bcbbacc9..036a740326 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -1053,8 +1053,8 @@ func (bc *BlockChain) procFutureBlocks() { } } if len(blocks) > 0 { - slices.SortFunc(blocks, func(a, b *types.Block) bool { - return a.NumberU64() < b.NumberU64() + slices.SortFunc(blocks, func(a, b *types.Block) int { + return a.Number().Cmp(b.Number()) }) // Insert one by one as chain insertion needs contiguous ancestry between blocks for i := range blocks { diff --git a/core/rawdb/accessors_chain.go b/core/rawdb/accessors_chain.go index 23cdc217b6..2bc245afb7 100644 --- a/core/rawdb/accessors_chain.go +++ b/core/rawdb/accessors_chain.go @@ -902,9 +902,9 @@ func WriteBadBlock(db ethdb.KeyValueStore, block *types.Block) { Header: block.Header(), Body: block.Body(), }) - slices.SortFunc(badBlocks, func(a, b *badBlock) bool { + slices.SortFunc(badBlocks, func(a, b *badBlock) int { // Note: sorting in descending number order. - return a.Header.Number.Uint64() >= b.Header.Number.Uint64() + return -a.Header.Number.Cmp(b.Header.Number) }) if len(badBlocks) > badBlockToKeep { badBlocks = badBlocks[:badBlockToKeep] diff --git a/core/rawdb/chain_iterator_test.go b/core/rawdb/chain_iterator_test.go index 9e18c8605c..9580cd92a8 100644 --- a/core/rawdb/chain_iterator_test.go +++ b/core/rawdb/chain_iterator_test.go @@ -19,12 +19,12 @@ package rawdb import ( "math/big" "reflect" + "sort" "sync" "testing" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" - "golang.org/x/exp/slices" ) func TestChainIterator(t *testing.T) { @@ -92,11 +92,9 @@ func TestChainIterator(t *testing.T) { } } if !c.reverse { - slices.Sort(numbers) + sort.Ints(numbers) } else { - slices.SortFunc(numbers, func(a, b int) bool { - return a > b // Sort descending - }) + sort.Sort(sort.Reverse(sort.IntSlice(numbers))) } if !reflect.DeepEqual(numbers, c.expect) { t.Fatalf("Case %d failed, visit element mismatch, want %v, got %v", i, c.expect, numbers) diff --git a/core/state/snapshot/difflayer.go b/core/state/snapshot/difflayer.go index b10b43b1ae..b6aca599c5 100644 --- a/core/state/snapshot/difflayer.go +++ b/core/state/snapshot/difflayer.go @@ -525,7 +525,7 @@ func (dl *diffLayer) AccountList() []common.Hash { dl.accountList = append(dl.accountList, hash) } } - slices.SortFunc(dl.accountList, common.Hash.Less) + slices.SortFunc(dl.accountList, common.Hash.Cmp) dl.memory += uint64(len(dl.accountList) * common.HashLength) return dl.accountList } @@ -563,7 +563,7 @@ func (dl *diffLayer) StorageList(accountHash common.Hash) ([]common.Hash, bool) for k := range storageMap { storageList = append(storageList, k) } - slices.SortFunc(storageList, common.Hash.Less) + slices.SortFunc(storageList, common.Hash.Cmp) dl.storageList[accountHash] = storageList dl.memory += uint64(len(dl.storageList)*common.HashLength + common.HashLength) return storageList, destructed diff --git a/core/state/snapshot/iterator_fast.go b/core/state/snapshot/iterator_fast.go index 339f930ffd..0502d9cf85 100644 --- a/core/state/snapshot/iterator_fast.go +++ b/core/state/snapshot/iterator_fast.go @@ -33,19 +33,25 @@ type weightedIterator struct { priority int } -func (it *weightedIterator) Less(other *weightedIterator) bool { +func (it *weightedIterator) Cmp(other *weightedIterator) int { // Order the iterators primarily by the account hashes hashI := it.it.Hash() hashJ := other.it.Hash() switch bytes.Compare(hashI[:], hashJ[:]) { case -1: - return true + return -1 case 1: - return false + return 1 } // Same account/storage-slot in multiple layers, split by priority - return it.priority < other.priority + if it.priority < other.priority { + return -1 + } + if it.priority > other.priority { + return 1 + } + return 0 } // fastIterator is a more optimized multi-layer iterator which maintains a @@ -155,9 +161,7 @@ func (fi *fastIterator) init() { } } // Re-sort the entire list - slices.SortFunc(fi.iterators, func(a, b *weightedIterator) bool { - return a.Less(b) - }) + slices.SortFunc(fi.iterators, func(a, b *weightedIterator) int { return a.Cmp(b) }) fi.initiated = false } diff --git a/eth/api_debug_test.go b/eth/api_debug_test.go index 4b08bd4fc5..6a1b537c25 100644 --- a/eth/api_debug_test.go +++ b/eth/api_debug_test.go @@ -105,7 +105,7 @@ func TestAccountRange(t *testing.T) { } // Test to see if it's possible to recover from the middle of the previous // set and get an even split between the first and second sets. - slices.SortFunc(hList, common.Hash.Less) + slices.SortFunc(hList, common.Hash.Cmp) middleH := hList[AccountRangeMaxResults/2] middleResult := accountRangeTest(t, &trie, sdb, middleH, AccountRangeMaxResults, AccountRangeMaxResults) missing, infirst, insecond := 0, 0, 0 diff --git a/eth/gasprice/feehistory.go b/eth/gasprice/feehistory.go index b9cee45ae7..226991b24b 100644 --- a/eth/gasprice/feehistory.go +++ b/eth/gasprice/feehistory.go @@ -111,8 +111,8 @@ func (oracle *Oracle) processBlock(bf *blockFees, percentiles []float64) { reward, _ := tx.EffectiveGasTip(bf.block.BaseFee()) sorter[i] = txGasAndReward{gasUsed: bf.receipts[i].GasUsed, reward: reward} } - slices.SortStableFunc(sorter, func(a, b txGasAndReward) bool { - return a.reward.Cmp(b.reward) < 0 + slices.SortStableFunc(sorter, func(a, b txGasAndReward) int { + return a.reward.Cmp(b.reward) }) var txIndex int diff --git a/eth/gasprice/gasprice.go b/eth/gasprice/gasprice.go index 9eccd72428..b719649811 100644 --- a/eth/gasprice/gasprice.go +++ b/eth/gasprice/gasprice.go @@ -208,7 +208,7 @@ func (oracle *Oracle) SuggestTipCap(ctx context.Context) (*big.Int, error) { } price := lastPrice if len(results) > 0 { - slices.SortFunc(results, func(a, b *big.Int) bool { return a.Cmp(b) < 0 }) + slices.SortFunc(results, func(a, b *big.Int) int { return a.Cmp(b) }) price = results[(len(results)-1)*oracle.percentile/100] } if price.Cmp(oracle.maxPrice) > 0 { @@ -247,12 +247,12 @@ func (oracle *Oracle) getBlockValues(ctx context.Context, blockNum uint64, limit sortedTxs := make([]*types.Transaction, len(txs)) copy(sortedTxs, txs) baseFee := block.BaseFee() - slices.SortFunc(sortedTxs, func(a, b *types.Transaction) bool { + slices.SortFunc(sortedTxs, func(a, b *types.Transaction) int { // It's okay to discard the error because a tx would never be // accepted into a block with an invalid effective tip. tip1, _ := a.EffectiveGasTip(baseFee) tip2, _ := b.EffectiveGasTip(baseFee) - return tip1.Cmp(tip2) < 0 + return tip1.Cmp(tip2) }) var prices []*big.Int diff --git a/eth/protocols/snap/sync_test.go b/eth/protocols/snap/sync_test.go index 8b09cd8c84..1514ad4e13 100644 --- a/eth/protocols/snap/sync_test.go +++ b/eth/protocols/snap/sync_test.go @@ -1417,8 +1417,8 @@ type kv struct { k, v []byte } -func (k *kv) less(other *kv) bool { - return bytes.Compare(k.k, other.k) < 0 +func (k *kv) cmp(other *kv) int { + return bytes.Compare(k.k, other.k) } func key32(i uint64) []byte { @@ -1478,7 +1478,7 @@ func makeAccountTrieNoStorage(n int, scheme string) (string, *trie.Trie, []*kv) accTrie.MustUpdate(elem.k, elem.v) entries = append(entries, elem) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // Commit the state changes into db and re-create the trie // for accessing later. @@ -1540,7 +1540,7 @@ func makeBoundaryAccountTrie(scheme string, n int) (string, *trie.Trie, []*kv) { accTrie.MustUpdate(elem.k, elem.v) entries = append(entries, elem) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // Commit the state changes into db and re-create the trie // for accessing later. @@ -1587,7 +1587,7 @@ func makeAccountTrieWithStorageWithUniqueStorage(scheme string, accounts, slots storageRoots[common.BytesToHash(key)] = stRoot storageEntries[common.BytesToHash(key)] = stEntries } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // Commit account trie root, set, _ := accTrie.Commit(true) @@ -1652,7 +1652,7 @@ func makeAccountTrieWithStorage(scheme string, accounts, slots int, code, bounda storageRoots[common.BytesToHash(key)] = stRoot storageEntries[common.BytesToHash(key)] = stEntries } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // Commit account trie root, set, _ := accTrie.Commit(true) @@ -1696,7 +1696,7 @@ func makeStorageTrieWithSeed(owner common.Hash, n, seed uint64, db *trie.Databas trie.MustUpdate(elem.k, elem.v) entries = append(entries, elem) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) root, nodes, _ := trie.Commit(false) return root, nodes, entries } @@ -1747,7 +1747,7 @@ func makeBoundaryStorageTrie(owner common.Hash, n int, db *trie.Database) (commo trie.MustUpdate(elem.k, elem.v) entries = append(entries, elem) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) root, nodes, _ := trie.Commit(false) return root, nodes, entries } diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index 11d7ff4b69..0f78af9a01 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -790,7 +790,7 @@ func newAccounts(n int) (accounts []Account) { addr := crypto.PubkeyToAddress(key.PublicKey) accounts = append(accounts, Account{key: key, addr: addr}) } - slices.SortFunc(accounts, func(a, b Account) bool { return a.addr.Less(b.addr) }) + slices.SortFunc(accounts, func(a, b Account) int { return a.addr.Cmp(b.addr) }) return accounts } diff --git a/ethdb/dbtest/testsuite.go b/ethdb/dbtest/testsuite.go index ac10ddde93..0d3d5f5aa6 100644 --- a/ethdb/dbtest/testsuite.go +++ b/ethdb/dbtest/testsuite.go @@ -527,7 +527,7 @@ func makeDataset(size, ksize, vsize int, order bool) ([][]byte, [][]byte) { vals = append(vals, randBytes(vsize)) } if order { - slices.SortFunc(keys, func(a, b []byte) bool { return bytes.Compare(a, b) < 0 }) + slices.SortFunc(keys, func(a, b []byte) int { return bytes.Compare(a, b) }) } return keys, vals } diff --git a/go.mod b/go.mod index 7694f6eeaf..e4273ef5b0 100644 --- a/go.mod +++ b/go.mod @@ -63,7 +63,7 @@ require ( github.com/urfave/cli/v2 v2.24.1 go.uber.org/automaxprocs v1.5.2 golang.org/x/crypto v0.9.0 - golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc + golang.org/x/exp v0.0.0-20230810033253-352e893a4cad golang.org/x/sync v0.3.0 golang.org/x/sys v0.9.0 golang.org/x/text v0.9.0 @@ -125,7 +125,7 @@ require ( github.com/tklauser/go-sysconf v0.3.5 // indirect github.com/tklauser/numcpus v0.2.2 // indirect github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect - golang.org/x/mod v0.10.0 // indirect + golang.org/x/mod v0.11.0 // indirect golang.org/x/net v0.10.0 // indirect golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect google.golang.org/protobuf v1.28.1 // indirect diff --git a/go.sum b/go.sum index a54b22e3dc..50271e857f 100644 --- a/go.sum +++ b/go.sum @@ -479,8 +479,8 @@ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5y golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g= golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= -golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc h1:mCRnTeVUjcrhlRmO0VK8a6k6Rrf6TF9htwo2pJVSjIU= -golang.org/x/exp v0.0.0-20230515195305-f3d0a9c9a5cc/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w= +golang.org/x/exp v0.0.0-20230810033253-352e893a4cad h1:g0bG7Z4uG+OgH2QDODnjp6ggkk1bJDsINcuWmJN1iJU= +golang.org/x/exp v0.0.0-20230810033253-352e893a4cad/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= @@ -490,8 +490,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk= -golang.org/x/mod v0.10.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU= +golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go index 671b9b2e49..b0877dc378 100644 --- a/internal/ethapi/api_test.go +++ b/internal/ethapi/api_test.go @@ -817,7 +817,7 @@ func newAccounts(n int) (accounts []Account) { addr := crypto.PubkeyToAddress(key.PublicKey) accounts = append(accounts, Account{key: key, addr: addr}) } - slices.SortFunc(accounts, func(a, b Account) bool { return a.addr.Less(b.addr) }) + slices.SortFunc(accounts, func(a, b Account) int { return a.addr.Cmp(b.addr) }) return accounts } diff --git a/les/servingqueue.go b/les/servingqueue.go index c25925403a..68cad9cb5a 100644 --- a/les/servingqueue.go +++ b/les/servingqueue.go @@ -215,8 +215,14 @@ func (sq *servingQueue) freezePeers() { tasks.list = append(tasks.list, task) tasks.sumTime += task.expTime } - slices.SortFunc(peerList, func(a, b *peerTasks) bool { - return a.priority < b.priority + slices.SortFunc(peerList, func(a, b *peerTasks) int { + if a.priority < b.priority { + return -1 + } + if a.priority > b.priority { + return 1 + } + return 0 }) drop := true for _, tasks := range peerList { diff --git a/les/utils/limiter.go b/les/utils/limiter.go index 155bd80150..70b7ff64f7 100644 --- a/les/utils/limiter.go +++ b/les/utils/limiter.go @@ -369,8 +369,14 @@ func (l *Limiter) dropRequests() { priority: w / float64(nq.sumCost), }) } - slices.SortFunc(list, func(a, b dropListItem) bool { - return a.priority < b.priority + slices.SortFunc(list, func(a, b dropListItem) int { + if a.priority < b.priority { + return -1 + } + if a.priority < b.priority { + return 1 + } + return 0 }) for _, item := range list { for _, request := range item.nq.queue { diff --git a/metrics/writer.go b/metrics/writer.go index 3d60485b6b..82434e9d1d 100644 --- a/metrics/writer.go +++ b/metrics/writer.go @@ -3,6 +3,7 @@ package metrics import ( "fmt" "io" + "strings" "time" "golang.org/x/exp/slices" @@ -23,8 +24,7 @@ func WriteOnce(r Registry, w io.Writer) { r.Each(func(name string, i interface{}) { namedMetrics = append(namedMetrics, namedMetric{name, i}) }) - - slices.SortFunc(namedMetrics, namedMetric.less) + slices.SortFunc(namedMetrics, namedMetric.cmp) for _, namedMetric := range namedMetrics { switch metric := namedMetric.m.(type) { case Counter: @@ -92,6 +92,6 @@ type namedMetric struct { m interface{} } -func (m namedMetric) less(other namedMetric) bool { - return m.name < other.name +func (m namedMetric) cmp(other namedMetric) int { + return strings.Compare(m.name, other.name) } diff --git a/metrics/writer_test.go b/metrics/writer_test.go index a4c92addc9..8376bf8975 100644 --- a/metrics/writer_test.go +++ b/metrics/writer_test.go @@ -14,7 +14,7 @@ func TestMetricsSorting(t *testing.T) { {name: "ggg"}, } - slices.SortFunc(namedMetrics, namedMetric.less) + slices.SortFunc(namedMetrics, namedMetric.cmp) for i, name := range []string{"bbb", "fff", "ggg", "zzz"} { if namedMetrics[i].name != name { t.Fail() diff --git a/p2p/discover/table_util_test.go b/p2p/discover/table_util_test.go index 52544a2c93..8f3813bdcf 100644 --- a/p2p/discover/table_util_test.go +++ b/p2p/discover/table_util_test.go @@ -217,14 +217,14 @@ func nodeEqual(n1 *enode.Node, n2 *enode.Node) bool { } func sortByID(nodes []*enode.Node) { - slices.SortFunc(nodes, func(a, b *enode.Node) bool { - return string(a.ID().Bytes()) < string(b.ID().Bytes()) + slices.SortFunc(nodes, func(a, b *enode.Node) int { + return bytes.Compare(a.ID().Bytes(), b.ID().Bytes()) }) } func sortedByDistanceTo(distbase enode.ID, slice []*node) bool { - return slices.IsSortedFunc(slice, func(a, b *node) bool { - return enode.DistCmp(distbase, a.ID(), b.ID()) < 0 + return slices.IsSortedFunc(slice, func(a, b *node) int { + return enode.DistCmp(distbase, a.ID(), b.ID()) }) } diff --git a/p2p/discover/v4_lookup_test.go b/p2p/discover/v4_lookup_test.go index 83c4626288..1f9ad69d0a 100644 --- a/p2p/discover/v4_lookup_test.go +++ b/p2p/discover/v4_lookup_test.go @@ -302,8 +302,8 @@ func (tn *preminedTestnet) closest(n int) (nodes []*enode.Node) { nodes = append(nodes, tn.node(d, i)) } } - slices.SortFunc(nodes, func(a, b *enode.Node) bool { - return enode.DistCmp(tn.target.id(), a.ID(), b.ID()) < 0 + slices.SortFunc(nodes, func(a, b *enode.Node) int { + return enode.DistCmp(tn.target.id(), a.ID(), b.ID()) }) return nodes[:n] } diff --git a/p2p/discover/v5_udp_test.go b/p2p/discover/v5_udp_test.go index 887d46c497..880b71a991 100644 --- a/p2p/discover/v5_udp_test.go +++ b/p2p/discover/v5_udp_test.go @@ -61,8 +61,8 @@ func TestUDPv5_lookupE2E(t *testing.T) { for i := range nodes { expectedResult[i] = nodes[i].Self() } - slices.SortFunc(expectedResult, func(a, b *enode.Node) bool { - return enode.DistCmp(target.ID(), a.ID(), b.ID()) < 0 + slices.SortFunc(expectedResult, func(a, b *enode.Node) int { + return enode.DistCmp(target.ID(), a.ID(), b.ID()) }) // Do the lookup. diff --git a/p2p/dnsdisc/tree.go b/p2p/dnsdisc/tree.go index f91aff458f..06b7681f18 100644 --- a/p2p/dnsdisc/tree.go +++ b/p2p/dnsdisc/tree.go @@ -214,8 +214,8 @@ func (t *Tree) build(entries []entry) entry { } func sortByID(nodes []*enode.Node) []*enode.Node { - slices.SortFunc(nodes, func(a, b *enode.Node) bool { - return bytes.Compare(a.ID().Bytes(), b.ID().Bytes()) < 0 + slices.SortFunc(nodes, func(a, b *enode.Node) int { + return bytes.Compare(a.ID().Bytes(), b.ID().Bytes()) }) return nodes } diff --git a/p2p/peer.go b/p2p/peer.go index e800be80fc..65a7903f58 100644 --- a/p2p/peer.go +++ b/p2p/peer.go @@ -386,7 +386,7 @@ func countMatchingProtocols(protocols []Protocol, caps []Cap) int { // matchProtocols creates structures for matching named subprotocols. func matchProtocols(protocols []Protocol, caps []Cap, rw MsgReadWriter) map[string]*protoRW { - slices.SortFunc(caps, Cap.Less) + slices.SortFunc(caps, Cap.Cmp) offset := baseProtocolLength result := make(map[string]*protoRW) diff --git a/p2p/protocol.go b/p2p/protocol.go index 4b3cca6d4a..9bb6785a22 100644 --- a/p2p/protocol.go +++ b/p2p/protocol.go @@ -18,6 +18,7 @@ package p2p import ( "fmt" + "strings" "github.com/ethereum/go-ethereum/p2p/enode" "github.com/ethereum/go-ethereum/p2p/enr" @@ -77,10 +78,16 @@ func (cap Cap) String() string { return fmt.Sprintf("%s/%d", cap.Name, cap.Version) } -// Less defines the canonical sorting order of capabilities. -func (cap Cap) Less(other Cap) bool { +// Cmp defines the canonical sorting order of capabilities. +func (cap Cap) Cmp(other Cap) int { if cap.Name == other.Name { - return cap.Version < other.Version + if cap.Version < other.Version { + return -1 + } + if cap.Version > other.Version { + return 1 + } + return 0 } - return cap.Name < other.Name + return strings.Compare(cap.Name, other.Name) } diff --git a/p2p/server.go b/p2p/server.go index d4e2be6783..8f42765a8c 100644 --- a/p2p/server.go +++ b/p2p/server.go @@ -510,7 +510,7 @@ func (srv *Server) setupLocalNode() error { for _, p := range srv.Protocols { srv.ourHandshake.Caps = append(srv.ourHandshake.Caps, p.cap()) } - slices.SortFunc(srv.ourHandshake.Caps, Cap.Less) + slices.SortFunc(srv.ourHandshake.Caps, Cap.Cmp) // Create the local node. db, err := enode.OpenDB(srv.NodeDatabase) diff --git a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go index 34f3959ff8..ba490b761f 100644 --- a/tests/fuzzers/rangeproof/rangeproof-fuzzer.go +++ b/tests/fuzzers/rangeproof/rangeproof-fuzzer.go @@ -98,8 +98,8 @@ func (f *fuzzer) fuzz() int { if len(entries) <= 1 { return 0 } - slices.SortFunc(entries, func(a, b *kv) bool { - return bytes.Compare(a.k, b.k) < 0 + slices.SortFunc(entries, func(a, b *kv) int { + return bytes.Compare(a.k, b.k) }) var ok = 0 diff --git a/tests/fuzzers/stacktrie/trie_fuzzer.go b/tests/fuzzers/stacktrie/trie_fuzzer.go index b8e13f96d1..3d65524095 100644 --- a/tests/fuzzers/stacktrie/trie_fuzzer.go +++ b/tests/fuzzers/stacktrie/trie_fuzzer.go @@ -182,8 +182,8 @@ func (f *fuzzer) fuzz() int { dbA.Commit(rootA, false) // Stacktrie requires sorted insertion - slices.SortFunc(vals, func(a, b kv) bool { - return bytes.Compare(a.k, b.k) < 0 + slices.SortFunc(vals, func(a, b kv) int { + return bytes.Compare(a.k, b.k) }) for _, kv := range vals { if f.debugging { diff --git a/trie/iterator_test.go b/trie/iterator_test.go index 5dc1faed59..57d1f06a16 100644 --- a/trie/iterator_test.go +++ b/trie/iterator_test.go @@ -81,8 +81,8 @@ type kv struct { t bool } -func (k *kv) less(other *kv) bool { - return bytes.Compare(k.k, other.k) < 0 +func (k *kv) cmp(other *kv) int { + return bytes.Compare(k.k, other.k) } func TestIteratorLargeData(t *testing.T) { diff --git a/trie/proof_test.go b/trie/proof_test.go index c943194586..fc2de62649 100644 --- a/trie/proof_test.go +++ b/trie/proof_test.go @@ -173,7 +173,7 @@ func TestRangeProof(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) for i := 0; i < 500; i++ { start := mrand.Intn(len(entries)) end := mrand.Intn(len(entries)-start) + start + 1 @@ -206,7 +206,7 @@ func TestRangeProofWithNonExistentProof(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) for i := 0; i < 500; i++ { start := mrand.Intn(len(entries)) end := mrand.Intn(len(entries)-start) + start + 1 @@ -278,7 +278,7 @@ func TestRangeProofWithInvalidNonExistentProof(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // Case 1 start, end := 100, 200 @@ -335,7 +335,7 @@ func TestOneElementRangeProof(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // One element with existent edge proof, both edge proofs // point to the SAME key. @@ -422,7 +422,7 @@ func TestAllElementsProof(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) var k [][]byte var v [][]byte @@ -474,7 +474,7 @@ func TestSingleSideRangeProof(t *testing.T) { trie.MustUpdate(value.k, value.v) entries = append(entries, value) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1} for _, pos := range cases { @@ -509,7 +509,7 @@ func TestReverseSingleSideRangeProof(t *testing.T) { trie.MustUpdate(value.k, value.v) entries = append(entries, value) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) var cases = []int{0, 1, 50, 100, 1000, 2000, len(entries) - 1} for _, pos := range cases { @@ -543,7 +543,7 @@ func TestBadRangeProof(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) for i := 0; i < 500; i++ { start := mrand.Intn(len(entries)) @@ -646,7 +646,7 @@ func TestSameSideProofs(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) pos := 1000 first := decreaseKey(common.CopyBytes(entries[pos].k)) @@ -690,7 +690,7 @@ func TestHasRightElement(t *testing.T) { trie.MustUpdate(value.k, value.v) entries = append(entries, value) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) var cases = []struct { start int @@ -762,7 +762,7 @@ func TestEmptyRangeProof(t *testing.T) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) var cases = []struct { pos int @@ -797,7 +797,7 @@ func TestBloatedProof(t *testing.T) { for _, kv := range kvs { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) var keys [][]byte var vals [][]byte @@ -831,7 +831,7 @@ func TestEmptyValueRangeProof(t *testing.T) { for _, kv := range values { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // Create a new entry with a slightly modified key mid := len(entries) / 2 @@ -875,7 +875,7 @@ func TestAllElementsEmptyValueRangeProof(t *testing.T) { for _, kv := range values { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) // Create a new entry with a slightly modified key mid := len(entries) / 2 @@ -981,7 +981,7 @@ func benchmarkVerifyRangeProof(b *testing.B, size int) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) start := 2 end := start + size @@ -1018,7 +1018,7 @@ func benchmarkVerifyRangeNoProof(b *testing.B, size int) { for _, kv := range vals { entries = append(entries, kv) } - slices.SortFunc(entries, (*kv).less) + slices.SortFunc(entries, (*kv).cmp) var keys [][]byte var values [][]byte diff --git a/trie/triedb/pathdb/history.go b/trie/triedb/pathdb/history.go index c12fc55184..ce82532507 100644 --- a/trie/triedb/pathdb/history.go +++ b/trie/triedb/pathdb/history.go @@ -262,20 +262,20 @@ func newHistory(root common.Hash, parent common.Hash, block uint64, states *trie for addr := range states.Accounts { accountList = append(accountList, addr) } - slices.SortFunc(accountList, func(a, b common.Address) bool { return a.Less(b) }) + slices.SortFunc(accountList, common.Address.Cmp) for addr, slots := range states.Storages { slist := make([]common.Hash, 0, len(slots)) for slotHash := range slots { slist = append(slist, slotHash) } - slices.SortFunc(slist, func(a, b common.Hash) bool { return a.Less(b) }) + slices.SortFunc(slist, common.Hash.Cmp) storageList[addr] = slist } for addr := range states.Incomplete { incomplete = append(incomplete, addr) } - slices.SortFunc(incomplete, func(a, b common.Address) bool { return a.Less(b) }) + slices.SortFunc(incomplete, common.Address.Cmp) return &history{ meta: &meta{ diff --git a/trie/triedb/pathdb/testutils.go b/trie/triedb/pathdb/testutils.go index 2efac87198..d6fdacb421 100644 --- a/trie/triedb/pathdb/testutils.go +++ b/trie/triedb/pathdb/testutils.go @@ -117,7 +117,7 @@ func hash(states map[common.Hash][]byte) (common.Hash, []byte) { for hash := range states { hs = append(hs, hash) } - slices.SortFunc(hs, func(a, b common.Hash) bool { return a.Less(b) }) + slices.SortFunc(hs, common.Hash.Cmp) var input []byte for _, hash := range hs { diff --git a/trie/trienode/node.go b/trie/trienode/node.go index 8998bcba06..98d5588b6d 100644 --- a/trie/trienode/node.go +++ b/trie/trienode/node.go @@ -18,10 +18,10 @@ package trienode import ( "fmt" + "sort" "strings" "github.com/ethereum/go-ethereum/common" - "golang.org/x/exp/slices" ) // Node is a wrapper which contains the encoded blob of the trie node and its @@ -83,9 +83,7 @@ func (set *NodeSet) ForEachWithOrder(callback func(path string, n *Node)) { paths = append(paths, path) } // Bottom-up, the longest path first - slices.SortFunc(paths, func(a, b string) bool { - return a > b // Sort in reverse order - }) + sort.Sort(sort.Reverse(sort.StringSlice(paths))) for _, path := range paths { callback(path, set.Nodes[path]) }