Nonfunctional changes (#1017)

* non-functional changes
* remove additional allocation from autoconf expand
* use slices.sort for sorting in autofconf
* slices.Clone instead of make + copy

Author: gammazero

autoconf/client.go

@@ -8,7 +8,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
-	"sort"
+	"slices"
 	"strings"
 	"sync"
 	"time"
@@ -256,9 +256,8 @@ func (c *Client) getCacheDir() (string, error) {
 	}
 
 	// Sort URLs for consistent hashing regardless of order
-	sortedURLs := make([]string, len(c.urls))
-	copy(sortedURLs, c.urls)
-	sort.Strings(sortedURLs)
+	sortedURLs := slices.Clone(c.urls)
+	slices.Sort(sortedURLs)
 
 	// Hash all URLs together for a single cache directory
 	h := fnv.New64a()

autoconf/expansion.go

@@ -2,16 +2,15 @@ package autoconf
 
 import (
 	"math/rand"
+	"slices"
 	"strings"
 )
 
 // normalizeURLs ensures all URLs in the slice have no trailing slashes
-func normalizeURLs(urls []string) []string {
-	normalized := make([]string, len(urls))
+func normalizeURLs(urls []string) {
 	for i, url := range urls {
-		normalized[i] = strings.TrimRight(url, "/")
+		urls[i] = strings.TrimRight(url, "/")
 	}
-	return normalized
 }
 
 // expandAutoConfSlice is a generic helper for expanding "auto" placeholders in string slices.
@@ -163,33 +162,30 @@ func ExpandDelegatedEndpoints(configEndpoints []string, autoConf *Config, native
 		return result
 	}
 
-	var routers []string
 	seen := make(map[string]struct{})
-
 	for baseURL, config := range endpoints {
 		// Combine both Read and Write paths (already filtered by WithSupportedPathsOnly)
-		allPaths := append(config.Read, config.Write...)
-
+		uniquePaths := slices.Concat(config.Read, config.Write)
 		// Deduplicate paths (in case same path appears in both Read and Write)
-		uniquePaths := make(map[string]struct{}, len(allPaths))
-		for _, path := range allPaths {
-			uniquePaths[path] = struct{}{}
-		}
+		slices.Sort(uniquePaths)
+		uniquePaths = slices.Compact(uniquePaths)
 
-		for path := range uniquePaths {
+		for _, path := range uniquePaths {
 			url := buildEndpointURL(baseURL, path)
-			if _, exists := seen[url]; !exists {
-				routers = append(routers, url)
-				seen[url] = struct{}{}
-			}
+			seen[url] = struct{}{}
 		}
 	}
 
+	routers := make([]string, 0, len(seen))
+	for url := range seen {
+		routers = append(routers, url)
+	}
+
 	resolved := expandAutoConfSlice(configEndpoints, routers)
 
 	// Normalize all URLs to ensure no trailing slashes
 	// (autoconf URLs are already normalized, but user-provided custom URLs might not be)
-	resolved = normalizeURLs(resolved)
+	normalizeURLs(resolved)
 
 	log.Debugf("ExpandDelegatedEndpoints: final result contains %d endpoints", len(resolved))
 	return resolved

autoconf/fetch.go

@@ -10,7 +10,7 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"sort"
+	"slices"
 	"strings"
 	"time"
 
@@ -390,8 +390,8 @@ func (c *Client) listCacheFiles(cacheDir string) ([]string, error) {
 	}
 
 	// Sort by filename (which contains unix timestamp) in descending order
-	sort.Slice(files, func(i, j int) bool {
-		return filepath.Base(files[i]) > filepath.Base(files[j])
+	slices.SortFunc(files, func(a, b string) int {
+		return strings.Compare(filepath.Base(b), filepath.Base(a))
 	})
 
 	return files, nil

autoconf/fetch_test.go

@@ -633,10 +633,7 @@ func TestCalculateEffectiveRefreshInterval(t *testing.T) {
 			// Verify the result is always the minimum of the two values (when server TTL > 0)
 			if tt.cacheTTL > 0 {
 				serverTTL := time.Duration(tt.cacheTTL) * time.Second
-				expectedMin := tt.userInterval
-				if serverTTL < tt.userInterval {
-					expectedMin = serverTTL
-				}
+				expectedMin := min(serverTTL, tt.userInterval)
 				assert.Equal(t, expectedMin, result, "result should be minimum of user interval and server TTL")
 			} else {
 				// When server TTL <= 0, should always return user interval

bitswap/network/httpnet/msg_sender.go

@@ -91,8 +91,7 @@ func (sender *httpMsgSender) sortURLS() []*senderURL {
 
 	// sender.urls must be read-only as multiple workers
 	// attempt to sort it.
-	urlCopy := make([]*senderURL, len(sender.urls))
-	copy(urlCopy, sender.urls)
+	urlCopy := slices.Clone(sender.urls)
 
 	slices.SortFunc(urlCopy, func(a, b *senderURL) int {
 		// urls without exhausted retries come first

ipld/unixfs/hamt/hamt.go

@@ -27,6 +27,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"slices"
 	"sync"
 
 	"github.com/gammazero/deque"
@@ -796,8 +797,7 @@ func (s *childer) makeChilder(data []byte, links []*ipld.Link) *childer {
 	s.children = make([]*Shard, len(links))
 	s.bitfield.SetBytes(data)
 	if len(links) > 0 {
-		s.links = make([]*ipld.Link, len(links))
-		copy(s.links, links)
+		s.links = slices.Clone(links)
 	}
 
 	return s
@@ -829,10 +829,12 @@ func (s *childer) insert(key string, lnk *ipld.Link, idx int) error {
 		return err
 	}
 
-	s.children = append(s.children[:i], append([]*Shard{sd}, s.children[i:]...)...)
-	s.links = append(s.links[:i], append([]*ipld.Link{nil}, s.links[i:]...)...)
+	s.children = slices.Insert(s.children, i, sd)
+
 	// Add a `nil` placeholder in `links` so the rest of the entries keep the same
 	// index as `children`.
+	s.links = slices.Insert(s.links, i, nil)
+
 	s.bitfield.SetBit(idx)
 
 	return nil
@@ -855,11 +857,8 @@ func (s *childer) rm(childIndex int) error {
 		return err
 	}
 
-	copy(s.children[i:], s.children[i+1:])
-	s.children = s.children[:len(s.children)-1]
-
-	copy(s.links[i:], s.links[i+1:])
-	s.links = s.links[:len(s.links)-1]
+	s.children = slices.Delete(s.children, i, i+1)
+	s.links = slices.Delete(s.links, i, i+1)
 
 	s.bitfield.UnsetBit(childIndex)
 

ipld/unixfs/mod/dagmodifier.go

@@ -167,10 +167,10 @@ func (dm *DagModifier) Size() (int64, error) {
 	if err != nil {
 		return 0, err
 	}
-	if dm.wrBuf != nil && int64(dm.wrBuf.Len())+int64(dm.writeStart) > int64(fileSize) {
-		return int64(dm.wrBuf.Len()) + int64(dm.writeStart), nil
+	if dm.wrBuf == nil {
+		return int64(fileSize), nil
 	}
-	return int64(fileSize), nil
+	return max(int64(fileSize), int64(dm.wrBuf.Len())+int64(dm.writeStart)), nil
 }
 
 func fileSize(n ipld.Node) (uint64, error) {

path/resolver/resolver.go

@@ -101,7 +101,8 @@ func (r *basicResolver) ResolveToLastNode(ctx context.Context, fpath path.Immuta
 
 	if len(nodes) < 1 {
 		return cid.Cid{}, nil, fmt.Errorf("path %v did not resolve to a node", fpath)
-	} else if len(nodes) < len(remainder) {
+	}
+	if len(nodes) < len(remainder) {
 		return cid.Undef, nil, &ErrNoLink{Name: remainder[len(nodes)-1], Node: lastCid}
 	}
 

peering/peering.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"math/rand"
+	"slices"
 	"strconv"
 	"sync"
 	"time"
@@ -68,8 +69,7 @@ type peerHandler struct {
 // setAddrs sets the addresses for this peer.
 func (ph *peerHandler) setAddrs(addrs []multiaddr.Multiaddr) {
 	// Not strictly necessary, but it helps to not trust the calling code.
-	addrCopy := make([]multiaddr.Multiaddr, len(addrs))
-	copy(addrCopy, addrs)
+	addrCopy := slices.Clone(addrs)
 
 	ph.mu.Lock()
 	defer ph.mu.Unlock()
@@ -265,9 +265,10 @@ func (ps *PeeringService) ListPeers() []peer.AddrInfo {
 
 	out := make([]peer.AddrInfo, 0, len(ps.peers))
 	for id, addrs := range ps.peers {
-		ai := peer.AddrInfo{ID: id}
-		ai.Addrs = append(ai.Addrs, addrs.addrs...)
-		out = append(out, ai)
+		out = append(out, peer.AddrInfo{
+			ID:    id,
+			Addrs: slices.Clone(addrs.addrs),
+		})
 	}
 	return out
 }