From 8bd9c519f3da004d3686b1d61bf8d261f021df0c Mon Sep 17 00:00:00 2001
From: Runxi Yu
Date: Thu, 5 Mar 2026 20:59:49 +0800
Subject: *: Fix lints

---
 format/pack/ingest/finalize.go        |  9 ++++++---
 format/pack/ingest/idx_write.go       | 38 ++++++++++++++++++++++++-----------
 format/pack/ingest/ingest.go          | 27 ++++++++++++++++---------
 format/pack/ingest/resolve.go         |  1 +
 format/pack/ingest/rev_write.go       | 19 ++++++++++++------
 format/pack/ingest/stream.go          | 30 ++++++++++++++++++---------
 format/pack/ingest/stream_scan.go     | 14 +++++++++----
 format/pack/ingest/temp.go            | 10 ++++++---
 format/pack/ingest/thin_fix.go        | 28 ++++++++++++++++++--------
 internal/compress/zlib/reader_test.go |  6 ++++--
 objectstore/loose/read_reader.go      |  2 +-
 11 files changed, 126 insertions(+), 58 deletions(-)

diff --git a/format/pack/ingest/finalize.go b/format/pack/ingest/finalize.go
index 86fef07c..e0516c4b 100644
--- a/format/pack/ingest/finalize.go
+++ b/format/pack/ingest/finalize.go
@@ -18,16 +18,19 @@ func finalizeArtifacts(state *ingestState) (Result, error) {
 		revFinal = base + ".rev"
 	}
 
-	if err := linkTempToFinal(state, state.packTmpName, packFinal); err != nil {
+	err := linkTempToFinal(state, state.packTmpName, packFinal)
+	if err != nil {
 		return Result{}, err
 	}
 
-	if err := linkTempToFinal(state, state.idxTmpName, idxFinal); err != nil {
+	err = linkTempToFinal(state, state.idxTmpName, idxFinal)
+	if err != nil {
 		return Result{}, err
 	}
 
 	if state.writeRev {
-		if err := linkTempToFinal(state, state.revTmpName, revFinal); err != nil {
+		err := linkTempToFinal(state, state.revTmpName, revFinal)
+		if err != nil {
 			return Result{}, err
 		}
 	}
diff --git a/format/pack/ingest/idx_write.go b/format/pack/ingest/idx_write.go
index f3d63b76..8db11ba0 100644
--- a/format/pack/ingest/idx_write.go
+++ b/format/pack/ingest/idx_write.go
@@ -24,11 +24,13 @@ func writeIdx(state *ingestState) error {
 	}
 
 	write := func(src []byte) error {
-		if _, err := state.idxFile.Write(src); err != nil {
+		_, err := state.idxFile.Write(src)
+		if err != nil {
 			return err
 		}
 
-		if _, err := hashImpl.Write(src); err != nil {
+		_, err = hashImpl.Write(src)
+		if err != nil {
 			return err
 		}
 
@@ -39,7 +41,8 @@ func writeIdx(state *ingestState) error {
 	binary.BigEndian.PutUint32(scratch[:4], idxMagicV2)
 	binary.BigEndian.PutUint32(scratch[4:8], idxVersionV2)
 
-	if err := write(scratch[:8]); err != nil {
+	err = write(scratch[:8])
+	if err != nil {
 		return err
 	}
 
@@ -55,14 +58,17 @@ func writeIdx(state *ingestState) error {
 		cumulative += fanout[i]
 		binary.BigEndian.PutUint32(scratch[:4], cumulative)
 
-		if err := write(scratch[:4]); err != nil {
+		err := write(scratch[:4])
+		if err != nil {
 			return err
 		}
 	}
 
 	for _, recordIdx := range order {
 		idRaw := state.records[recordIdx].objectID.Bytes()
-		if err := write(idRaw); err != nil {
+
+		err := write(idRaw)
+		if err != nil {
 			return err
 		}
 	}
@@ -70,7 +76,8 @@ func writeIdx(state *ingestState) error {
 	for _, recordIdx := range order {
 		binary.BigEndian.PutUint32(scratch[:4], state.records[recordIdx].crc32)
 
-		if err := write(scratch[:4]); err != nil {
+		err := write(scratch[:4])
+		if err != nil {
 			return err
 		}
 	}
@@ -88,7 +95,8 @@ func writeIdx(state *ingestState) error {
 			binary.BigEndian.PutUint32(scratch[:4], uint32(offset))
 		}
 
-		if err := write(scratch[:4]); err != nil {
+		err := write(scratch[:4])
+		if err != nil {
 			return err
 		}
 	}
@@ -96,17 +104,21 @@ func writeIdx(state *ingestState) error {
 	for _, off := range largeOffsets {
 		binary.BigEndian.PutUint64(scratch[:8], off)
 
-		if err := write(scratch[:8]); err != nil {
+		err := write(scratch[:8])
+		if err != nil {
 			return err
 		}
 	}
 
-	if err := write(state.packHash.Bytes()); err != nil {
+	err = write(state.packHash.Bytes())
+	if err != nil {
 		return err
 	}
 
 	idxHash := hashImpl.Sum(nil)
-	if _, err := state.idxFile.Write(idxHash); err != nil {
+
+	_, err = state.idxFile.Write(idxHash)
+	if err != nil {
 		return err
 	}
 
@@ -140,11 +152,13 @@ func verifyResolvedRecords(state *ingestState) error {
 
 // writeAndHash writes src to dst and updates hash.
 func writeAndHash(dst io.Writer, hashImpl hash.Hash, src []byte) error {
-	if _, err := dst.Write(src); err != nil {
+	_, err := dst.Write(src)
+	if err != nil {
 		return err
 	}
 
-	if _, err := hashImpl.Write(src); err != nil {
+	_, err = hashImpl.Write(src)
+	if err != nil {
 		return err
 	}
 
diff --git a/format/pack/ingest/ingest.go b/format/pack/ingest/ingest.go
index 4ae7ff2c..df6c6627 100644
--- a/format/pack/ingest/ingest.go
+++ b/format/pack/ingest/ingest.go
@@ -4,7 +4,8 @@ import "fmt"
 
 // ingest initializes transaction state and executes the ingest pipeline.
 func ingest(state *ingestState) (out Result, err error) {
-	if err := openTemporaryArtifacts(state); err != nil {
+	err = openTemporaryArtifacts(state)
+	if err != nil {
 		return Result{}, err
 	}
 
@@ -15,20 +16,24 @@ func ingest(state *ingestState) (out Result, err error) {
 		}
 	}()
 
-	if err := streamPackAndScan(state); err != nil {
+	err = streamPackAndScan(state)
+	if err != nil {
 		return Result{}, err
 	}
 
-	if err := resolveAll(state); err != nil {
+	err = resolveAll(state)
+	if err != nil {
 		return Result{}, err
 	}
 
-	if err := maybeFixThin(state); err != nil {
+	err = maybeFixThin(state)
+	if err != nil {
 		return Result{}, err
 	}
 
 	if state.thinFixed {
-		if err := resolveAll(state); err != nil {
+		err := resolveAll(state)
+		if err != nil {
 			return Result{}, err
 		}
 	}
@@ -37,19 +42,23 @@ func ingest(state *ingestState) (out Result, err error) {
 		return Result{}, &ErrThinPackUnresolved{Count: len(state.unresolvedRefDeltas)}
 	}
 
-	if err := verifyResolvedRecords(state); err != nil {
+	err = verifyResolvedRecords(state)
+	if err != nil {
 		return Result{}, err
 	}
 
-	if err := state.packFile.Sync(); err != nil {
+	err = state.packFile.Sync()
+	if err != nil {
 		return Result{}, &ErrDestinationWrite{Op: fmt.Sprintf("sync pack: %v", err)}
 	}
 
-	if err := writeIdx(state); err != nil {
+	err = writeIdx(state)
+	if err != nil {
 		return Result{}, err
 	}
 
-	if err := writeRev(state); err != nil {
+	err = writeRev(state)
+	if err != nil {
 		return Result{}, err
 	}
 
diff --git a/format/pack/ingest/resolve.go b/format/pack/ingest/resolve.go
index f5dfb28a..f024bb62 100644
--- a/format/pack/ingest/resolve.go
+++ b/format/pack/ingest/resolve.go
@@ -32,6 +32,7 @@ func resolveAll(state *ingestState) error {
 		if err != nil {
 			if errors.Is(err, errExternalThinBase) {
 				state.unresolvedRefDeltas = append(state.unresolvedRefDeltas, idx)
+
 				continue
 			}
 
diff --git a/format/pack/ingest/rev_write.go b/format/pack/ingest/rev_write.go
index 5e9dbcbd..d7eab31f 100644
--- a/format/pack/ingest/rev_write.go
+++ b/format/pack/ingest/rev_write.go
@@ -35,36 +35,43 @@ func writeRev(state *ingestState) error {
 	var scratch [8]byte
 	binary.BigEndian.PutUint32(scratch[:4], revMagic)
 
-	if err := writeAndHash(state.revFile, hashImpl, scratch[:4]); err != nil {
+	err = writeAndHash(state.revFile, hashImpl, scratch[:4])
+	if err != nil {
 		return err
 	}
 
 	binary.BigEndian.PutUint32(scratch[:4], revVersion)
 
-	if err := writeAndHash(state.revFile, hashImpl, scratch[:4]); err != nil {
+	err = writeAndHash(state.revFile, hashImpl, scratch[:4])
+	if err != nil {
 		return err
 	}
 
 	binary.BigEndian.PutUint32(scratch[:4], hashID(state.algo))
 
-	if err := writeAndHash(state.revFile, hashImpl, scratch[:4]); err != nil {
+	err = writeAndHash(state.revFile, hashImpl, scratch[:4])
+	if err != nil {
 		return err
 	}
 
 	for _, recordIdx := range packOrder {
 		binary.BigEndian.PutUint32(scratch[:4], uint32(recordToIdxPos[recordIdx]))
 
-		if err := writeAndHash(state.revFile, hashImpl, scratch[:4]); err != nil {
+		err := writeAndHash(state.revFile, hashImpl, scratch[:4])
+		if err != nil {
 			return err
 		}
 	}
 
-	if err := writeAndHash(state.revFile, hashImpl, state.packHash.Bytes()); err != nil {
+	err = writeAndHash(state.revFile, hashImpl, state.packHash.Bytes())
+	if err != nil {
 		return err
 	}
 
 	revHash := hashImpl.Sum(nil)
-	if _, err := state.revFile.Write(revHash); err != nil {
+
+	_, err = state.revFile.Write(revHash)
+	if err != nil {
 		return err
 	}
 
diff --git a/format/pack/ingest/stream.go b/format/pack/ingest/stream.go
index 78302da2..4c6b59ab 100644
--- a/format/pack/ingest/stream.go
+++ b/format/pack/ingest/stream.go
@@ -2,6 +2,7 @@ package ingest
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"hash"
 	"hash/crc32"
@@ -60,7 +61,8 @@ func (scanner *streamScanner) fill(min int) error {
 	}
 
 	for scanner.n-scanner.off < min {
-		if err := scanner.flushConsumedPrefix(); err != nil {
+		err := scanner.flushConsumedPrefix()
+		if err != nil {
 			return err
 		}
 
@@ -70,7 +72,7 @@ func (scanner *streamScanner) fill(min int) error {
 		}
 
 		if err != nil {
-			if err == io.EOF && scanner.n-scanner.off >= min {
+			if errors.Is(err, io.EOF) && scanner.n-scanner.off >= min {
 				return nil
 			}
 
@@ -97,7 +99,8 @@ func (scanner *streamScanner) use(n int) error {
 
 	chunk := scanner.buf[scanner.off : scanner.off+n]
 	if scanner.hashEnabled {
-		if _, err := scanner.hash.Write(chunk); err != nil {
+		_, err := scanner.hash.Write(chunk)
+		if err != nil {
 			return err
 		}
 	}
@@ -119,8 +122,9 @@ func (scanner *streamScanner) Read(dst []byte) (int, error) {
 	}
 
 	if scanner.n-scanner.off == 0 {
-		if err := scanner.fill(1); err != nil {
-			if err == io.EOF {
+		err := scanner.fill(1)
+		if err != nil {
+			if errors.Is(err, io.EOF) {
 				return 0, io.EOF
 			}
 
@@ -140,7 +144,8 @@ func (scanner *streamScanner) Read(dst []byte) (int, error) {
 
 	copy(dst, scanner.buf[scanner.off:scanner.off+n])
 
-	if err := scanner.use(n); err != nil {
+	err := scanner.use(n)
+	if err != nil {
 		return 0, err
 	}
 
@@ -150,13 +155,16 @@ func (scanner *streamScanner) Read(dst []byte) (int, error) {
 // ReadByte implements io.ByteReader without allocation.
 func (scanner *streamScanner) ReadByte() (byte, error) {
 	if scanner.n-scanner.off == 0 {
-		if err := scanner.fill(1); err != nil {
+		err := scanner.fill(1)
+		if err != nil {
 			return 0, err
 		}
 	}
 
 	b := scanner.buf[scanner.off]
-	if err := scanner.use(1); err != nil {
+
+	err := scanner.use(1)
+	if err != nil {
 		return 0, err
 	}
 
@@ -188,7 +196,9 @@ func (scanner *streamScanner) finishAndFlushTrailer() error {
 	trailer := make([]byte, scanner.hashSize)
 
 	scanner.hashEnabled = false
-	if err := scanner.readFull(trailer); err != nil {
+
+	err := scanner.readFull(trailer)
+	if err != nil {
 		return &ErrPackTrailerMismatch{}
 	}
 
@@ -201,7 +211,7 @@ func (scanner *streamScanner) finishAndFlushTrailer() error {
 		return fmt.Errorf("format/pack/ingest: pack has trailing garbage")
 	}
 
-	if err != io.EOF {
+	if !errors.Is(err, io.EOF) {
 		return err
 	}
 
diff --git a/format/pack/ingest/stream_scan.go b/format/pack/ingest/stream_scan.go
index 8f429e43..b3cf4c00 100644
--- a/format/pack/ingest/stream_scan.go
+++ b/format/pack/ingest/stream_scan.go
@@ -27,7 +27,8 @@ func streamPackAndScan(state *ingestState) error {
 		state.algo.Size(),
 	)
 
-	if err := readAndValidatePackHeader(state); err != nil {
+	err = readAndValidatePackHeader(state)
+	if err != nil {
 		return err
 	}
 
@@ -46,7 +47,8 @@ func streamPackAndScan(state *ingestState) error {
 		}
 	}
 
-	if err := state.stream.finishAndFlushTrailer(); err != nil {
+	err = state.stream.finishAndFlushTrailer()
+	if err != nil {
 		return err
 	}
 
@@ -67,7 +69,9 @@ func streamPackAndScan(state *ingestState) error {
 // readAndValidatePackHeader reads and validates PACK header from the stream.
 func readAndValidatePackHeader(state *ingestState) error {
 	var hdr [12]byte
-	if err := state.stream.readFull(hdr[:]); err != nil {
+
+	err := state.stream.readFull(hdr[:])
+	if err != nil {
 		return &ErrInvalidPackHeader{Reason: fmt.Sprintf("read header: %v", err)}
 	}
 
@@ -199,7 +203,9 @@ func parseEntryPrefix(state *ingestState, startOffset uint64) (objectRecord, err
 	case objecttype.TypeCommit, objecttype.TypeTree, objecttype.TypeBlob, objecttype.TypeTag:
 	case objecttype.TypeRefDelta:
 		baseRaw := make([]byte, state.algo.Size())
-		if err := state.stream.readFull(baseRaw); err != nil {
+
+		err := state.stream.readFull(baseRaw)
+		if err != nil {
 			return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: fmt.Sprintf("read ref base: %v", err)}
 		}
 
diff --git a/format/pack/ingest/temp.go b/format/pack/ingest/temp.go
index d0297ace..597ec487 100644
--- a/format/pack/ingest/temp.go
+++ b/format/pack/ingest/temp.go
@@ -51,8 +51,10 @@ func openTemporaryArtifacts(state *ingestState) error {
 // closeTemporaryArtifacts closes all temporary artifact file descriptors.
 func closeTemporaryArtifacts(state *ingestState) error {
 	var out error
+
 	if state.packFile != nil {
-		if err := state.packFile.Close(); err != nil && out == nil {
+		err := state.packFile.Close()
+		if err != nil && out == nil {
 			out = err
 		}
 
@@ -60,7 +62,8 @@ func closeTemporaryArtifacts(state *ingestState) error {
 	}
 
 	if state.idxFile != nil {
-		if err := state.idxFile.Close(); err != nil && out == nil {
+		err := state.idxFile.Close()
+		if err != nil && out == nil {
 			out = err
 		}
 
@@ -68,7 +71,8 @@ func closeTemporaryArtifacts(state *ingestState) error {
 	}
 
 	if state.revFile != nil {
-		if err := state.revFile.Close(); err != nil && out == nil {
+		err := state.revFile.Close()
+		if err != nil && out == nil {
 			out = err
 		}
 
diff --git a/format/pack/ingest/thin_fix.go b/format/pack/ingest/thin_fix.go
index 15fe7674..05ad9494 100644
--- a/format/pack/ingest/thin_fix.go
+++ b/format/pack/ingest/thin_fix.go
@@ -39,7 +39,9 @@ func maybeFixThin(state *ingestState) error {
 	}
 
 	newEnd := size - hashSize
-	if err := state.packFile.Truncate(newEnd); err != nil {
+
+	err = state.packFile.Truncate(newEnd)
+	if err != nil {
 		return err
 	}
 
@@ -52,14 +54,16 @@ func maybeFixThin(state *ingestState) error {
 			continue
 		}
 
-		if _, err := appendBaseObject(state, id, ty, content); err != nil {
+		_, err = appendBaseObject(state, id, ty, content)
+		if err != nil {
 			return err
 		}
 
 		state.thinFixed = true
 	}
 
-	if err := rewritePackHeaderAndTrailer(state); err != nil {
+	err = rewritePackHeaderAndTrailer(state)
+	if err != nil {
 		return err
 	}
 
@@ -71,7 +75,9 @@ func appendBaseObject(state *ingestState, id objectid.ObjectID, realType objectt
 	start := state.stream.consumed
 
 	header := encodePackEntryHeader(realType, int64(len(content)))
-	if _, err := state.packFile.WriteAt(header, int64(start)); err != nil {
+
+	_, err := state.packFile.WriteAt(header, int64(start))
+	if err != nil {
 		return 0, err
 	}
 
@@ -81,11 +87,14 @@ func appendBaseObject(state *ingestState, id objectid.ObjectID, realType objectt
 	counting := &countingWriter{dst: section}
 
 	zw := zlib.NewWriter(io.MultiWriter(counting, crc))
-	if _, err := zw.Write(content); err != nil {
+
+	_, err = zw.Write(content)
+	if err != nil {
 		return 0, err
 	}
 
-	if err := zw.Close(); err != nil {
+	err = zw.Close()
+	if err != nil {
 		return 0, err
 	}
 
@@ -153,7 +162,8 @@ func rewritePackHeaderAndTrailer(state *ingestState) error {
 	var countRaw [4]byte
 	binary.BigEndian.PutUint32(countRaw[:], uint32(len(state.records)))
 
-	if _, err := state.packFile.WriteAt(countRaw[:], 8); err != nil {
+	_, err := state.packFile.WriteAt(countRaw[:], 8)
+	if err != nil {
 		return err
 	}
 
@@ -195,7 +205,9 @@ func rewritePackHeaderAndTrailer(state *ingestState) error {
 	}
 
 	sum := hashImpl.Sum(nil)
-	if _, err := state.packFile.WriteAt(sum, endWithoutTrailer); err != nil {
+
+	_, err = state.packFile.WriteAt(sum, endWithoutTrailer)
+	if err != nil {
 		return err
 	}
 
diff --git a/internal/compress/zlib/reader_test.go b/internal/compress/zlib/reader_test.go
index 9b534b1e..e8a44007 100644
--- a/internal/compress/zlib/reader_test.go
+++ b/internal/compress/zlib/reader_test.go
@@ -182,11 +182,13 @@ func TestDecompressor(t *testing.T) {
 		}
 
 		// Check for sticky errors.
-		if n, err := zr.Read([]byte{0}); n != 0 || !errors.Is(err, io.EOF) {
+		n1, err := zr.Read([]byte{0})
+		if n1 != 0 || !errors.Is(err, io.EOF) {
 			t.Errorf("%s: Read() = (%d, %v), want (0, io.EOF)", tt.desc, n, err)
 		}
 
-		if err := zr.Close(); err != nil {
+		err = zr.Close()
+		if err != nil {
 			t.Errorf("%s: Close() = %v, want nil", tt.desc, err)
 		}
 	}
diff --git a/objectstore/loose/read_reader.go b/objectstore/loose/read_reader.go
index 6f434840..035aeaad 100644
--- a/objectstore/loose/read_reader.go
+++ b/objectstore/loose/read_reader.go
@@ -7,8 +7,8 @@ import (
 	"io"
 	"os"
 
-	"codeberg.org/lindenii/furgit/internal/iolimit"
 	"codeberg.org/lindenii/furgit/internal/compress/zlib"
+	"codeberg.org/lindenii/furgit/internal/iolimit"
 	"codeberg.org/lindenii/furgit/objectid"
 	"codeberg.org/lindenii/furgit/objecttype"
 )
-- 
cgit v1.3.1-10-gc9f91