refactor: using reflect.TypeFor (#13353)

Author: cuiweixie

api/docgen-openrpc/openrpc.go

@@ -112,7 +112,7 @@ func OpenRPCSchemaTypeMapper(ty reflect.Type) *jsonschema.Type {
 		ty = ty.Elem()
 	}
 
-	if ty == reflect.TypeOf((*interface{})(nil)).Elem() {
+	if ty == reflect.TypeFor[interface{}]() {
 		return &jsonschema.Type{Type: "object", AdditionalProperties: []byte("true")}
 	}
 

api/docgen/docgen.go

@@ -52,12 +52,12 @@ import (
 )
 
 var ExampleValues = map[reflect.Type]interface{}{
-	reflect.TypeOf(api.MinerSubsystem(0)): api.MinerSubsystem(1),
-	reflect.TypeOf(auth.Permission("")):   auth.Permission("write"),
-	reflect.TypeOf(""):                    "string value",
-	reflect.TypeOf(uint64(42)):            uint64(42),
-	reflect.TypeOf(byte(7)):               byte(7),
-	reflect.TypeOf([]byte{}):              []byte("byte array"),
+	reflect.TypeFor[api.MinerSubsystem](): api.MinerSubsystem(1),
+	reflect.TypeFor[auth.Permission]():    auth.Permission("write"),
+	reflect.TypeFor[string]():             "string value",
+	reflect.TypeFor[uint64]():             uint64(42),
+	reflect.TypeFor[byte]():               byte(7),
+	reflect.TypeFor[[]byte]():             []byte("byte array"),
 }
 
 func addExample(v interface{}) {
@@ -70,8 +70,8 @@ func init() {
 		panic(err)
 	}
 
-	ExampleValues[reflect.TypeOf(c)] = c
-	ExampleValues[reflect.TypeOf(&c)] = &c
+	ExampleValues[reflect.TypeFor[cid.Cid]()] = c
+	ExampleValues[reflect.TypeFor[*cid.Cid]()] = &c
 
 	c2, err := cid.Decode("bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve")
 	if err != nil {
@@ -80,15 +80,15 @@ func init() {
 
 	tsk := types.NewTipSetKey(c, c2)
 
-	ExampleValues[reflect.TypeOf(tsk)] = tsk
+	ExampleValues[reflect.TypeFor[types.TipSetKey]()] = tsk
 
 	addr, err := address.NewIDAddress(1234)
 	if err != nil {
 		panic(err)
 	}
 
-	ExampleValues[reflect.TypeOf(addr)] = addr
-	ExampleValues[reflect.TypeOf(&addr)] = &addr
+	ExampleValues[reflect.TypeFor[address.Address]()] = addr
+	ExampleValues[reflect.TypeFor[*address.Address]()] = &addr
 
 	var ts types.TipSet
 	err = json.Unmarshal(tipsetSampleJson, &ts)
@@ -143,8 +143,7 @@ func init() {
 	addExample(&f3Cert)
 
 	block := blocks.Block(&blocks.BasicBlock{})
-	ExampleValues[reflect.TypeOf(&block).Elem()] = block
-
+	ExampleValues[reflect.TypeFor[blocks.Block]()] = block
 	addExample(bitfield.NewFromSet([]uint64{5}))
 	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1_1)
 	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
@@ -187,9 +186,7 @@ func init() {
 	addExample(map[string]int{"name": 42})
 	addExample(map[string]time.Time{"name": time.Unix(1615243938, 0).UTC()})
 	addExample(abi.ActorID(1000))
-	addExample(map[string]types.Actor{
-		"t01236": ExampleValue("init", reflect.TypeOf(types.Actor{}), nil).(types.Actor),
-	})
+	addExample(map[string]types.Actor{"t01236": ExampleValue("init", reflect.TypeFor[types.Actor](), nil).(types.Actor)})
 	addExample(types.IpldOpGet)
 	addExample(&types.TraceIpld{
 		Op:   types.IpldOpGet,

chain/vm/invoker.go

@@ -129,8 +129,8 @@ func (ar *ActorRegistry) Register(av actorstypes.Version, pred ActorPredicate, v
 		// Explicitly add send, it's special.
 		methods[builtin.MethodSend] = MethodMeta{
 			Name:   "Send",
-			Params: reflect.TypeOf(new(abi.EmptyValue)),
-			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
+			Params: reflect.TypeFor[*abi.EmptyValue](),
+			Ret:    reflect.TypeFor[*abi.EmptyValue](),
 		}
 
 		// Iterate over exported methods. Some of these _may_ be nil and
@@ -191,7 +191,7 @@ type invokee interface {
 func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
 	itype := reflect.TypeOf(instance)
 	exports := instance.Exports()
-	runtimeType := reflect.TypeOf((*vmr.Runtime)(nil)).Elem()
+	runtimeType := reflect.TypeFor[vmr.Runtime]()
 	for i, e := range exports {
 		i := i
 		m := e.Method
@@ -225,7 +225,7 @@ func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
 				"cbg.CBORMarshaler")
 		}
 		o0 := t.Out(0)
-		if !o0.Implements(reflect.TypeOf((*cbg.CBORMarshaler)(nil)).Elem()) {
+		if !o0.Implements(reflect.TypeFor[cbg.CBORMarshaler]()) {
 			return nil, newErr("output needs to implement cgb.CBORMarshaler")
 		}
 	}
@@ -236,7 +236,7 @@ func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
 			continue
 		}
 		meth := reflect.ValueOf(m)
-		code[id] = reflect.MakeFunc(reflect.TypeOf((invokeFunc)(nil)),
+		code[id] = reflect.MakeFunc(reflect.TypeFor[invokeFunc](),
 			func(in []reflect.Value) []reflect.Value {
 				paramT := meth.Type().In(1).Elem()
 				param := reflect.New(paramT)

cli/worker/worker.go

@@ -320,7 +320,7 @@ Example invocation of lotus-bench as external executor:
 
 		// Check DC-environment variable
 		sectorSizes := []string{"2KiB", "8MiB", "512MiB", "32GiB", "64GiB"}
-		resourcesType := reflect.TypeOf(storiface.Resources{})
+		resourcesType := reflect.TypeFor[storiface.Resources]()
 
 		for _, sectorSize := range sectorSizes {
 			for i := 0; i < resourcesType.NumField(); i++ {

cmd/lotus-shed/state-stats.go

@@ -827,7 +827,7 @@ func collectSnapshotJobStats(ctx context.Context, in job, dag format.NodeGetter,
 			varType := v.Type().Field(i).Type
 			varValue := v.Field(i).Interface()
 
-			if varType == reflect.TypeOf(cid.Cid{}) {
+			if varType == reflect.TypeFor[cid.Cid]() {
 				subjobs = append(subjobs, job{
 					key: fmt.Sprintf("%s/%s", in.key, varName),
 					c:   varValue.(cid.Cid),
@@ -894,7 +894,7 @@ func collectStats(ctx context.Context, addr address.Address, actor *types.Actor,
 			varType := v.Type().Field(i).Type
 			varValue := v.Field(i).Interface()
 
-			if varType == reflect.TypeOf(cid.Cid{}) {
+			if varType == reflect.TypeFor[cid.Cid]() {
 				fields = append(fields, fieldItem{
 					Name: varName,
 					Cid:  varValue.(cid.Cid),