internal/godoc/codec: use reflect.TypeFor instead of reflect.TypeOf

Updates golang/go#60088

Change-Id: I0ba56ce30a81f1ff3ea941971cca36b57e02e4b4
Reviewed-on: https://go-review.googlesource.com/c/pkgsite/+/709176
kokoro-CI: kokoro <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Carlos Amedee <[email protected]>
Auto-Submit: Sean Liao <[email protected]>
Reviewed-by: Michael Pratt <[email protected]>
Reviewed-by: Sean Liao <[email protected]>

Author: cuishuang

internal/godoc/codec/generate.go

@@ -107,8 +107,7 @@ func generate(w io.Writer, packageName string, fieldNames map[string][]string, v
 	}
 	// The empty interface doesn't need any additional code. It's tricky to get
 	// its reflect.Type: we need to dereference the pointer type.
-	var iface any
-	g.done[reflect.TypeOf(&iface).Elem()] = true
+	g.done[reflect.TypeFor[any]()] = true
 
 	src, err := g.generate()
 	if err != nil {
@@ -384,18 +383,18 @@ func (g *generator) decodeStatement(t reflect.Type, arg string) string {
 func builtinName(t reflect.Type) (suffix string, native reflect.Type) {
 	switch t.Kind() {
 	case reflect.String:
-		return "String", reflect.TypeOf("")
+		return "String", reflect.TypeFor[string]()
 	case reflect.Bool:
-		return "Bool", reflect.TypeOf(true)
+		return "Bool", reflect.TypeFor[bool]()
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return "Int", reflect.TypeOf(int64(0))
+		return "Int", reflect.TypeFor[int64]()
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return "Uint", reflect.TypeOf(uint64(0))
+		return "Uint", reflect.TypeFor[uint64]()
 	case reflect.Float32, reflect.Float64:
-		return "Float64", reflect.TypeOf(0.0)
+		return "Float64", reflect.TypeFor[float64]()
 	case reflect.Slice:
-		if t.Elem() == reflect.TypeOf(byte(0)) {
-			return "Bytes", reflect.TypeOf([]byte(nil))
+		if t.Elem() == reflect.TypeFor[byte]() {
+			return "Bytes", reflect.TypeFor[[]byte]()
 		}
 	}
 	return "", nil

internal/godoc/codec/generate_test.go

@@ -77,32 +77,32 @@ func TestExportedFields(t *testing.T) {
 	}
 
 	// First time we see ef, no previous fields.
-	got := exportedFields(reflect.TypeOf(ef{}), nil)
+	got := exportedFields(reflect.TypeFor[ef](), nil)
 	want := []field{
-		{"A", reflect.TypeOf(0), "0"},
-		{"B", reflect.TypeOf(false), "false"},
-		{"C", reflect.TypeOf(""), `""`},
+		{"A", reflect.TypeFor[int](), "0"},
+		{"B", reflect.TypeFor[bool](), "false"},
+		{"C", reflect.TypeFor[string](), `""`},
 	}
 	check(want, got)
 
 	// Imagine that the previous ef had fields C and A in that order, but not B.
 	// We should preserve the existing ordering and add B at the end.
-	got = exportedFields(reflect.TypeOf(ef{}), []string{"C", "A"})
+	got = exportedFields(reflect.TypeFor[ef](), []string{"C", "A"})
 	want = []field{
-		{"C", reflect.TypeOf(""), `""`},
-		{"A", reflect.TypeOf(0), "0"},
-		{"B", reflect.TypeOf(false), "false"},
+		{"C", reflect.TypeFor[string](), `""`},
+		{"A", reflect.TypeFor[int](), "0"},
+		{"B", reflect.TypeFor[bool](), "false"},
 	}
 	check(want, got)
 
 	// Imagine instead that there had been a field D that was removed.
 	// We still keep the names, but the entry for "D" has a nil type.
-	got = exportedFields(reflect.TypeOf(ef{}), []string{"A", "D", "B", "C"})
+	got = exportedFields(reflect.TypeFor[ef](), []string{"A", "D", "B", "C"})
 	want = []field{
-		{"A", reflect.TypeOf(0), "0"},
+		{"A", reflect.TypeFor[int](), "0"},
 		{"D", nil, ""},
-		{"B", reflect.TypeOf(false), "false"},
-		{"C", reflect.TypeOf(""), `""`},
+		{"B", reflect.TypeFor[bool](), "false"},
+		{"C", reflect.TypeFor[string](), `""`},
 	}
 	check(want, got)
 }