Merge branch 'lukeshu/lint'

4 files changed, 43 insertions, 34 deletions

diff --git a/lib/btrfs/btrfstree/ops.go b/lib/btrfs/btrfstree/ops.go
index f2eb6f0..537773a 100644
--- a/lib/btrfs/btrfstree/ops.go
+++ b/lib/btrfs/btrfstree/ops.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022  Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023  Luke Shumaker <lukeshu@lukeshu.com>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -156,14 +156,12 @@ func (fs TreeOperatorImpl) treeWalk(ctx context.Context, path TreePath, errHandl
 	}
 	if err != nil {
 		errHandle(&TreeError{Path: path, Err: err})
-	} else {
-		if cbs.Node != nil {
-			if err := cbs.Node(path, node); err != nil {
-				if errors.Is(err, iofs.SkipDir) {
-					return
-				}
-				errHandle(&TreeError{Path: path, Err: err})
+	} else if cbs.Node != nil {
+		if err := cbs.Node(path, node); err != nil {
+			if errors.Is(err, iofs.SkipDir) {
+				return
 			}
+			errHandle(&TreeError{Path: path, Err: err})
 		}
 	}
 	if ctx.Err() != nil {
@@ -506,7 +504,7 @@ func (fs TreeOperatorImpl) TreeSearchAll(treeID btrfsprim.ObjID, fn func(btrfspr
 	}
 	middleItem := middleNode.Data.BodyLeaf[middlePath.Node(-1).FromItemIdx]
 
-	var ret = []Item{middleItem}
+	ret := []Item{middleItem}
 	var errs derror.MultiError
 	for prevPath, prevNode := middlePath, middleNode; true; {
 		prevPath, prevNode, err = fs.prev(prevPath, prevNode)
diff --git a/lib/btrfs/btrfstree/root.go b/lib/btrfs/btrfstree/root.go
index 12df0b2..6ec45b5 100644
--- a/lib/btrfs/btrfstree/root.go
+++ b/lib/btrfs/btrfstree/root.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022  Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023  Luke Shumaker <lukeshu@lukeshu.com>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -71,15 +71,18 @@ func LookupTreeRoot(fs TreeOperator, sb Superblock, treeID btrfsprim.ObjID) (*Tr
 		if err != nil {
 			return nil, err
 		}
-		rootItemBody, ok := rootItem.Body.(btrfsitem.Root)
-		if !ok {
-			return nil, fmt.Errorf("malformed ROOT_ITEM for tree %v", treeID)
+		switch rootItemBody := rootItem.Body.(type) {
+		case btrfsitem.Root:
+			return &TreeRoot{
+				TreeID:     treeID,
+				RootNode:   rootItemBody.ByteNr,
+				Level:      rootItemBody.Level,
+				Generation: rootItemBody.Generation,
+			}, nil
+		case btrfsitem.Error:
+			return nil, fmt.Errorf("malformed ROOT_ITEM for tree %v: %w", treeID, rootItemBody.Err)
+		default:
+			panic(fmt.Errorf("should not happen: ROOT_ITEM has unexpected item type: %T", rootItemBody))
 		}
-		return &TreeRoot{
-			TreeID:     treeID,
-			RootNode:   rootItemBody.ByteNr,
-			Level:      rootItemBody.Level,
-			Generation: rootItemBody.Generation,
-		}, nil
 	}
 }
diff --git a/lib/btrfs/btrfstree/types_node.go b/lib/btrfs/btrfstree/types_node.go
index 299c433..a26215b 100644
--- a/lib/btrfs/btrfstree/types_node.go
+++ b/lib/btrfs/btrfstree/types_node.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022  Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023  Luke Shumaker <lukeshu@lukeshu.com>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -23,19 +23,23 @@ import (
 
 type NodeFlags uint64
 
+const sizeofNodeFlags = 7
+
 func (NodeFlags) BinaryStaticSize() int {
-	return 7
+	return sizeofNodeFlags
 }
+
 func (f NodeFlags) MarshalBinary() ([]byte, error) {
 	var bs [8]byte
 	binary.LittleEndian.PutUint64(bs[:], uint64(f))
-	return bs[:7], nil
+	return bs[:sizeofNodeFlags], nil
 }
+
 func (f *NodeFlags) UnmarshalBinary(dat []byte) (int, error) {
 	var bs [8]byte
-	copy(bs[:7], dat[:7])
+	copy(bs[:sizeofNodeFlags], dat[:sizeofNodeFlags])
 	*f = NodeFlags(binary.LittleEndian.Uint64(bs[:]))
-	return 7, nil
+	return sizeofNodeFlags, nil
 }
 
 var (
@@ -212,10 +216,11 @@ func (node Node) MarshalBinary() ([]byte, error) {
 
 	if bs, err := binstruct.Marshal(node.Head); err != nil {
 		return buf, err
-	} else if len(bs) != binstruct.StaticSize(NodeHeader{}) {
-		return nil, fmt.Errorf("header is %v bytes but expected %v",
-			len(bs), binstruct.StaticSize(NodeHeader{}))
 	} else {
+		if len(bs) != binstruct.StaticSize(NodeHeader{}) {
+			return nil, fmt.Errorf("header is %v bytes but expected %v",
+				len(bs), binstruct.StaticSize(NodeHeader{}))
+		}
 		copy(buf, bs)
 	}
 
@@ -417,9 +422,11 @@ func (e *IOError) Unwrap() error { return e.Err }
 // NodeError are ErrNotANode and *IOError.
 func ReadNode[Addr ~int64](fs diskio.File[Addr], sb Superblock, addr Addr, exp NodeExpectations) (*diskio.Ref[Addr, Node], error) {
 	if int(sb.NodeSize) < binstruct.StaticSize(NodeHeader{}) {
-		return nil, &NodeError[Addr]{Op: "btrfstree.ReadNode", NodeAddr: addr,
+		return nil, &NodeError[Addr]{
+			Op: "btrfstree.ReadNode", NodeAddr: addr,
 			Err: fmt.Errorf("superblock.NodeSize=%v is too small to contain even a node header (%v bytes)",
-				sb.NodeSize, binstruct.StaticSize(NodeHeader{}))}
+				sb.NodeSize, binstruct.StaticSize(NodeHeader{})),
+		}
 	}
 	nodeBuf := make([]byte, sb.NodeSize)
 	if _, err := fs.ReadAt(nodeBuf, addr); err != nil {
@@ -455,9 +462,11 @@ func ReadNode[Addr ~int64](fs diskio.File[Addr], sb Superblock, addr Addr, exp N
 		return nodeRef, &NodeError[Addr]{Op: "btrfstree.ReadNode", NodeAddr: addr, Err: err}
 	}
 	if stored != calced {
-		return nodeRef, &NodeError[Addr]{Op: "btrfstree.ReadNode", NodeAddr: addr,
+		return nodeRef, &NodeError[Addr]{
+			Op: "btrfstree.ReadNode", NodeAddr: addr,
 			Err: fmt.Errorf("looks like a node but is corrupt: checksum mismatch: stored=%v calculated=%v",
-				stored, calced)}
+				stored, calced),
+		}
 	}
 
 	// parse (main)
diff --git a/lib/btrfs/btrfstree/types_node_test.go b/lib/btrfs/btrfstree/types_node_test.go
index 040b90c..80855d8 100644
--- a/lib/btrfs/btrfstree/types_node_test.go
+++ b/lib/btrfs/btrfstree/types_node_test.go
@@ -1,4 +1,4 @@
-// Copyright (C) 2022  Luke Shumaker <lukeshu@lukeshu.com>
+// Copyright (C) 2022-2023  Luke Shumaker <lukeshu@lukeshu.com>
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -23,13 +23,12 @@ func FuzzRoundTripNode(f *testing.F) {
 		n, err := binstruct.Unmarshal(inDat, &node)
 		if err != nil {
 			t.Logf("err=%v", err)
-			//require.Equal(t, 0, n)
 		} else {
 			require.Equal(t, len(inDat), n)
 
 			outDat, err := binstruct.Marshal(node)
 			require.NoError(t, err)
-			require.Equal(t, inDat[:], outDat)
+			require.Equal(t, inDat, outDat)
 		}
 	})
 }