part: Move the leaf pointer out of the header

To avoid having the useless 'leaf' field in the leaf struct,
move it out from header into each individual node struct.

We still have the 'prefix' in the leaf struct that could in
principle be removed by special-casing, e.g. instead of
always looking at the prefix one would first check if the
node is a leaf and then do full key comparison instead.
Leaving that for a later commit.

Signed-off-by: Jussi Maki <[email protected]>

part/node.go

@@ -25,7 +25,6 @@ const (
 type header[T any] struct {
 	flags  uint16        // kind(4b) | unused(3b) | size(9b)
 	prefix []byte        // the compressed prefix, [0] is the key
-	leaf   *leaf[T]      // non-nil if this node contains a value
 	watch  chan struct{} // watch channel that is closed when this node mutates
 }
 
@@ -63,10 +62,37 @@ func (n *header[T]) isLeaf() bool {
 }
 
 func (n *header[T]) getLeaf() *leaf[T] {
-	if n.isLeaf() {
+	switch n.kind() {
+	case nodeKindLeaf:
 		return (*leaf[T])(unsafe.Pointer(n))
+	case nodeKind4:
+		return n.node4().leaf
+	case nodeKind16:
+		return n.node16().leaf
+	case nodeKind48:
+		return n.node48().leaf
+	case nodeKind256:
+		return n.node256().leaf
+	default:
+		panic("unknown node kind")
+	}
+}
+
+func (n *header[T]) setLeaf(l *leaf[T]) {
+	switch n.kind() {
+	case nodeKindLeaf:
+		panic("cannot setLeaf on a leaf[T]")
+	case nodeKind4:
+		n.node4().leaf = l
+	case nodeKind16:
+		n.node16().leaf = l
+	case nodeKind48:
+		n.node48().leaf = l
+	case nodeKind256:
+		n.node256().leaf = l
+	default:
+		panic("unknown node kind")
 	}
-	return n.leaf
 }
 
 func (n *header[T]) size() int {
@@ -296,21 +322,25 @@ func newLeaf[T any](o *options, prefix, key []byte, value T) *leaf[T] {
 
 type node4[T any] struct {
 	header[T]
+	leaf     *leaf[T] // non-nil if this node contains a value
 	children [4]*header[T]
 }
 
 type node16[T any] struct {
 	header[T]
+	leaf     *leaf[T] // non-nil if this node contains a value
 	children [16]*header[T]
 }
 
 type node48[T any] struct {
 	header[T]
+	leaf     *leaf[T] // non-nil if this node contains a value
 	children [48]*header[T]
 }
 
 type node256[T any] struct {
 	header[T]
+	leaf     *leaf[T] // non-nil if this node contains a value
 	children [256]*header[T]
 }
 

part/txn.go

@@ -153,7 +153,7 @@ func (txn *Txn[T]) insert(root *header[T], key []byte, value T) (oldValue T, had
 					hadOld = true
 				} else {
 					// This is a non-leaf node, create/replace the existing leaf.
-					this.leaf = newLeaf(txn.opts, key, fullKey, value)
+					this.setLeaf(newLeaf(txn.opts, key, fullKey, value))
 				}
 				return
 			}
@@ -267,7 +267,7 @@ func (txn *Txn[T]) delete(root *header[T], key []byte) (oldValue T, hadOld bool,
 			newRoot = newNode4[T]()
 		} else {
 			newRoot = txn.cloneNode(root)
-			newRoot.leaf = nil
+			newRoot.setLeaf(nil)
 		}
 		return
 	}
@@ -293,11 +293,11 @@ func (txn *Txn[T]) delete(root *header[T], key []byte) (oldValue T, hadOld bool,
 			// This is the node that we want to delete, but it has
 			// children. Clone and clear the leaf.
 			target.node = txn.cloneNode(target.node)
-			target.node.leaf = nil
+			target.node.setLeaf(nil)
 			children[target.index] = target.node
 		}
 
-		if target.node.size() == 0 && (target.node == this || target.node.leaf == nil) {
+		if target.node.size() == 0 && (target.node == this || target.node.getLeaf() == nil) {
 			// The node is empty, remove it from the parent.
 			parent.node.remove(target.index)
 		} else {