Use generic function to box values on heap

Resolve post-1.18 todo to define a generic function that boxes a value on the
heap.

Author: willbeason

cmp/compare_test.go

@@ -104,13 +104,11 @@ func mustFormatGolden(path string, in []struct{ Name, Data string }) {
 
 var now = time.Date(2009, time.November, 10, 23, 00, 00, 00, time.UTC)
 
-// TODO(≥go1.18): Define a generic function that boxes a value on the heap.
-func newInt(n int) *int { return &n }
+func newT[T any](t T) *T { return &t }
 
 type Stringer string
 
-func newStringer(s string) fmt.Stringer { return (*Stringer)(&s) }
-func (s Stringer) String() string       { return string(s) }
+func (s Stringer) String() string { return string(s) }
 
 type test struct {
 	label     string       // Test name
@@ -319,29 +317,29 @@ func comparerTests() []test {
 		reason:    "unexported fields result in a panic by default",
 	}, {
 		label:     label + "/PointerStructEqual",
-		x:         &struct{ A *int }{newInt(4)},
-		y:         &struct{ A *int }{newInt(4)},
+		x:         &struct{ A *int }{newT[int](4)},
+		y:         &struct{ A *int }{newT[int](4)},
 		wantEqual: true,
 		reason:    "comparison of pointer to struct with equal A field",
 	}, {
 		label:     label + "/PointerStructInequal",
-		x:         &struct{ A *int }{newInt(4)},
-		y:         &struct{ A *int }{newInt(5)},
+		x:         &struct{ A *int }{newT[int](4)},
+		y:         &struct{ A *int }{newT[int](5)},
 		wantEqual: false,
 		reason:    "comparison of pointer to struct with inequal A field",
 	}, {
 		label: label + "/PointerStructTrueComparer",
-		x:     &struct{ A *int }{newInt(4)},
-		y:     &struct{ A *int }{newInt(5)},
+		x:     &struct{ A *int }{newT[int](4)},
+		y:     &struct{ A *int }{newT[int](5)},
 		opts: []cmp.Option{
 			cmp.Comparer(func(x, y int) bool { return true }),
 		},
 		wantEqual: true,
 		reason:    "comparison of pointer to struct with inequal A field, but treated as equal with always equal comparer",
 	}, {
 		label: label + "/PointerStructNonNilComparer",
-		x:     &struct{ A *int }{newInt(4)},
-		y:     &struct{ A *int }{newInt(5)},
+		x:     &struct{ A *int }{newT[int](4)},
+		y:     &struct{ A *int }{newT[int](5)},
 		opts: []cmp.Option{
 			cmp.Comparer(func(x, y *int) bool { return x != nil && y != nil }),
 		},
@@ -909,35 +907,35 @@ func reporterTests() []test {
 		reason:    "reporter should display the qualified type name to disambiguate between the two values",
 	}, {
 		label: label + "/AmbiguousPointer",
-		x:     newInt(0),
-		y:     newInt(0),
+		x:     newT[int](0),
+		y:     newT[int](0),
 		opts: []cmp.Option{
 			cmp.Comparer(func(x, y *int) bool { return x == y }),
 		},
 		wantEqual: false,
 		reason:    "reporter should display the address to disambiguate between the two values",
 	}, {
 		label: label + "/AmbiguousPointerStruct",
-		x:     struct{ I *int }{newInt(0)},
-		y:     struct{ I *int }{newInt(0)},
+		x:     struct{ I *int }{newT[int](0)},
+		y:     struct{ I *int }{newT[int](0)},
 		opts: []cmp.Option{
 			cmp.Comparer(func(x, y *int) bool { return x == y }),
 		},
 		wantEqual: false,
 		reason:    "reporter should display the address to disambiguate between the two struct fields",
 	}, {
 		label: label + "/AmbiguousPointerSlice",
-		x:     []*int{newInt(0)},
-		y:     []*int{newInt(0)},
+		x:     []*int{newT[int](0)},
+		y:     []*int{newT[int](0)},
 		opts: []cmp.Option{
 			cmp.Comparer(func(x, y *int) bool { return x == y }),
 		},
 		wantEqual: false,
 		reason:    "reporter should display the address to disambiguate between the two slice elements",
 	}, {
 		label: label + "/AmbiguousPointerMap",
-		x:     map[string]*int{"zero": newInt(0)},
-		y:     map[string]*int{"zero": newInt(0)},
+		x:     map[string]*int{"zero": newT[int](0)},
+		y:     map[string]*int{"zero": newT[int](0)},
 		opts: []cmp.Option{
 			cmp.Comparer(func(x, y *int) bool { return x == y }),
 		},
@@ -946,25 +944,25 @@ func reporterTests() []test {
 	}, {
 		label:     label + "/AmbiguousStringer",
 		x:         Stringer("hello"),
-		y:         newStringer("hello"),
+		y:         newT[Stringer]("hello"),
 		wantEqual: false,
 		reason:    "reporter should avoid calling String to disambiguate between the two values",
 	}, {
 		label:     label + "/AmbiguousStringerStruct",
 		x:         struct{ S fmt.Stringer }{Stringer("hello")},
-		y:         struct{ S fmt.Stringer }{newStringer("hello")},
+		y:         struct{ S fmt.Stringer }{newT[Stringer]("hello")},
 		wantEqual: false,
 		reason:    "reporter should avoid calling String to disambiguate between the two struct fields",
 	}, {
 		label:     label + "/AmbiguousStringerSlice",
 		x:         []fmt.Stringer{Stringer("hello")},
-		y:         []fmt.Stringer{newStringer("hello")},
+		y:         []fmt.Stringer{newT[Stringer]("hello")},
 		wantEqual: false,
 		reason:    "reporter should avoid calling String to disambiguate between the two slice elements",
 	}, {
 		label:     label + "/AmbiguousStringerMap",
 		x:         map[string]fmt.Stringer{"zero": Stringer("hello")},
-		y:         map[string]fmt.Stringer{"zero": newStringer("hello")},
+		y:         map[string]fmt.Stringer{"zero": newT[Stringer]("hello")},
 		wantEqual: false,
 		reason:    "reporter should avoid calling String to disambiguate between the two map values",
 	}, {
@@ -984,15 +982,15 @@ func reporterTests() []test {
 			foo1.Bar{"fizz"}:  "buzz",
 		},
 		y: map[interface{}]string{
-			newStringer("hello"): "goodbye",
-			foo2.Bar{"fizz"}:     "buzz",
+			newT[Stringer]("hello"): "goodbye",
+			foo2.Bar{"fizz"}:        "buzz",
 		},
 		wantEqual: false,
 		reason:    "reporter should avoid calling String to disambiguate between the two map keys",
 	}, {
 		label:     label + "/NonAmbiguousStringerMapKey",
 		x:         map[interface{}]string{Stringer("hello"): "goodbye"},
-		y:         map[interface{}]string{newStringer("fizz"): "buzz"},
+		y:         map[interface{}]string{newT[Stringer]("fizz"): "buzz"},
 		wantEqual: false,
 		reason:    "reporter should call String as there is no ambiguity between the two map keys",
 	}, {
@@ -2594,7 +2592,7 @@ func project1Tests() []test {
 						Target: "corporation",
 						Immutable: &ts.GoatImmutable{
 							ID:      "southbay",
-							State:   (*pb.Goat_States)(newInt(5)),
+							State:   (*pb.Goat_States)(newT[int](5)),
 							Started: now,
 						},
 					},
@@ -2622,7 +2620,7 @@ func project1Tests() []test {
 			Immutable: &ts.EagleImmutable{
 				ID:          "eagleID",
 				Birthday:    now,
-				MissingCall: (*pb.Eagle_MissingCalls)(newInt(55)),
+				MissingCall: (*pb.Eagle_MissingCalls)(newT[int](55)),
 			},
 		}
 	}
@@ -2671,7 +2669,7 @@ func project1Tests() []test {
 		x: func() ts.Eagle {
 			eg := createEagle()
 			eg.Dreamers[1].Animal[0].(ts.Goat).Immutable.ID = "southbay2"
-			eg.Dreamers[1].Animal[0].(ts.Goat).Immutable.State = (*pb.Goat_States)(newInt(6))
+			eg.Dreamers[1].Animal[0].(ts.Goat).Immutable.State = (*pb.Goat_States)(newT[int](6))
 			eg.Slaps[0].Immutable.MildSlap = false
 			return eg
 		}(),