Refactor FindSubtrees to return (Subtree, Subtree, error) directly

Update FindSubtrees in proof/proof.go to return two Subtree structs
by value instead of allocating a []Subtree slice.

TAG=agy
CONV=1f76bf92-7d8b-43a5-942a-a4bd88025626

Author: phbnf

proof/proof.go

@@ -285,15 +285,15 @@ type Subtree struct {
 //   - If the provided subtree has a size <= 1, then this function returns that subtree and an empty subtree.
 //   - If the provided [start, end) range is already a valid subtree, then it is still split into two smaller subtrees.
 //   - The 2nd subtree, if not empty, is adjacent to the first, and may not be a perfect subtree.
-//   - The returned subtree(s) fully cover the [start, end) range.
+//   - The returned subtrees fully cover the [start, end) range.
 //   - There are no "extra" entries covered past end, but there may be covered entries prior to start.
 //   - The number of entries covered before start is always less than half the size of the first returned subtree.
-func FindSubtrees(start, end uint64) ([]Subtree, error) {
+func FindSubtrees(start, end uint64) (Subtree, Subtree, error) {
 	if start > end {
-		return nil, fmt.Errorf("start %d must be less than or equal to end %d", start, end)
+		return Subtree{}, Subtree{}, fmt.Errorf("start %d must be less than or equal to end %d", start, end)
 	}
 	if end-start <= 1 {
-		return []Subtree{{Start: start, End: end}, {Start: end, End: end}}, nil
+		return Subtree{Start: start, End: end}, Subtree{Start: end, End: end}, nil
 	}
 	last := end - 1
 	// Find where start and last's tree paths diverge.
@@ -304,10 +304,7 @@ func FindSubtrees(start, end uint64) ([]Subtree, error) {
 	// Maximize the left endpoint.
 	leftSplit := bits.Len64(^start & mask)
 	leftStart := start & ^((uint64(1) << leftSplit) - 1)
-	return []Subtree{
-		{Start: leftStart, End: mid},
-		{Start: mid, End: end},
-	}, nil
+	return Subtree{Start: leftStart, End: mid}, Subtree{Start: mid, End: end}, nil
 }
 
 // isSubtreeValid returns whether a subtree covers a valid range.

proof/proof_test.go

@@ -825,25 +825,26 @@ func inclusion(t *testing.T, index, size uint64) Nodes {
 func TestFindSubtrees(t *testing.T) {
 	for _, tc := range []struct {
 		start, end uint64
-		want       []Subtree
+		wantLeft   Subtree
+		wantRight  Subtree
 		wantErr    bool
 	}{
-		// Already-valid subtrees are returned as-is.
 		// Single entry subtrees:
-		{start: 0, end: 1, want: []Subtree{{Start: 0, End: 1}, {Start: 1, End: 1}}},
-		{start: 3, end: 4, want: []Subtree{{Start: 3, End: 4}, {Start: 4, End: 4}}},
+		{start: 0, end: 1, wantLeft: Subtree{Start: 0, End: 1}, wantRight: Subtree{Start: 1, End: 1}},
+		{start: 3, end: 4, wantLeft: Subtree{Start: 3, End: 4}, wantRight: Subtree{Start: 4, End: 4}},
 		// Perfectly aligned subtrees:
-		{start: 4, end: 6, want: []Subtree{{Start: 4, End: 5}, {Start: 5, End: 6}}},
-		{start: 16, end: 32, want: []Subtree{{Start: 16, End: 24}, {Start: 24, End: 32}}},
+		{start: 4, end: 6, wantLeft: Subtree{Start: 4, End: 5}, wantRight: Subtree{Start: 5, End: 6}},
+		{start: 16, end: 32, wantLeft: Subtree{Start: 16, End: 24}, wantRight: Subtree{Start: 24, End: 32}},
 		// Non-perfect trees are split into two:
-		{start: 5, end: 13, want: []Subtree{{Start: 4, End: 8}, {Start: 8, End: 13}}},
-		{start: 7, end: 9, want: []Subtree{{Start: 7, End: 8}, {Start: 8, End: 9}}},
+		{start: 5, end: 13, wantLeft: Subtree{Start: 4, End: 8}, wantRight: Subtree{Start: 8, End: 13}},
+		{start: 7, end: 9, wantLeft: Subtree{Start: 7, End: 8}, wantRight: Subtree{Start: 8, End: 9}},
+		// Empty subtrees.
+		{start: 5, end: 5, wantLeft: Subtree{Start: 5, End: 5}, wantRight: Subtree{Start: 5, End: 5}},
 		// Invalid inputs:
-		{start: 5, end: 5, want: []Subtree{{Start: 5, End: 5}, {Start: 5, End: 5}}},
 		{start: 6, end: 5, wantErr: true},
 	} {
 		t.Run(fmt.Sprintf("%d:%d", tc.start, tc.end), func(t *testing.T) {
-			got, err := FindSubtrees(tc.start, tc.end)
+			gotLeft, gotRight, err := FindSubtrees(tc.start, tc.end)
 			if tc.wantErr {
 				if err == nil {
 					t.Fatal("expected error, got nil")
@@ -853,8 +854,11 @@ func TestFindSubtrees(t *testing.T) {
 			if err != nil {
 				t.Fatalf("FindSubtrees: %v", err)
 			}
-			if diff := cmp.Diff(tc.want, got); diff != "" {
-				t.Errorf("FindSubtrees mismatch (-want +got):\n%s", diff)
+			if diff := cmp.Diff(tc.wantLeft, gotLeft); diff != "" {
+				t.Errorf("FindSubtrees left mismatch (-want +got):\n%s", diff)
+			}
+			if diff := cmp.Diff(tc.wantRight, gotRight); diff != "" {
+				t.Errorf("FindSubtrees right mismatch (-want +got):\n%s", diff)
 			}
 		})
 	}

testonly/vectors_test.go

@@ -130,14 +130,11 @@ func TestSubtreeCoveringVectors(t *testing.T) {
 	h := sha256.New()
 	for end := range subtreeVectorMax + 1 {
 		for start := range end + 1 {
-			subtrees, err := proof.FindSubtrees(start, end)
+			left, right, err := proof.FindSubtrees(start, end)
 			if err != nil {
 				t.Fatalf("FindSubtrees(%d, %d): %v", start, end, err)
 			}
-			if l := len(subtrees); l != 2 {
-				t.Fatalf("FindSubtrees(%d, %d) returned unexpected number of subtrees: %d", start, end, l)
-			}
-			if _, err := fmt.Fprintf(h, "[%d, %d) [%d, %d)\n", subtrees[0].Start, subtrees[0].End, subtrees[1].Start, subtrees[1].End); err != nil {
+			if _, err := fmt.Fprintf(h, "[%d, %d) [%d, %d)\n", left.Start, left.End, right.Start, right.End); err != nil {
 				t.Fatalf("fmt.Fprintf: %v", err)
 			}
 		}