updated dependencies and go

reflectext/casting.go

@@ -5,23 +5,23 @@ import (
 )
 
 var reflectBasicTypes = map[reflect.Kind]reflect.Type{
-	reflect.Bool:       reflect.TypeOf(false),
-	reflect.Int:        reflect.TypeOf(int(0)),
-	reflect.Int8:       reflect.TypeOf(int8(0)),
-	reflect.Int16:      reflect.TypeOf(int16(0)),
-	reflect.Int32:      reflect.TypeOf(int32(0)),
-	reflect.Int64:      reflect.TypeOf(int64(0)),
-	reflect.Uint:       reflect.TypeOf(uint(0)),
-	reflect.Uint8:      reflect.TypeOf(uint8(0)),
-	reflect.Uint16:     reflect.TypeOf(uint16(0)),
-	reflect.Uint32:     reflect.TypeOf(uint32(0)),
-	reflect.Uint64:     reflect.TypeOf(uint64(0)),
-	reflect.Uintptr:    reflect.TypeOf(uintptr(0)),
-	reflect.Float32:    reflect.TypeOf(float32(0)),
-	reflect.Float64:    reflect.TypeOf(float64(0)),
-	reflect.Complex64:  reflect.TypeOf(complex64(0)),
-	reflect.Complex128: reflect.TypeOf(complex128(0)),
-	reflect.String:     reflect.TypeOf(""),
+	reflect.Bool:       reflect.TypeFor[bool](),
+	reflect.Int:        reflect.TypeFor[int](),
+	reflect.Int8:       reflect.TypeFor[int8](),
+	reflect.Int16:      reflect.TypeFor[int16](),
+	reflect.Int32:      reflect.TypeFor[int32](),
+	reflect.Int64:      reflect.TypeFor[int64](),
+	reflect.Uint:       reflect.TypeFor[uint](),
+	reflect.Uint8:      reflect.TypeFor[uint8](),
+	reflect.Uint16:     reflect.TypeFor[uint16](),
+	reflect.Uint32:     reflect.TypeFor[uint32](),
+	reflect.Uint64:     reflect.TypeFor[uint64](),
+	reflect.Uintptr:    reflect.TypeFor[uintptr](),
+	reflect.Float32:    reflect.TypeFor[float32](),
+	reflect.Float64:    reflect.TypeFor[float64](),
+	reflect.Complex64:  reflect.TypeFor[complex64](),
+	reflect.Complex128: reflect.TypeFor[complex128](),
+	reflect.String:     reflect.TypeFor[string](),
 }
 
 // Underlying returns the underlying type of t (without type alias)
@@ -48,17 +48,17 @@ func Underlying(t reflect.Type) (ret reflect.Type) {
 		nOut := t.NumOut()
 		in := make([]reflect.Type, nIn)
 		out := make([]reflect.Type, nOut)
-		for i := 0; i < nIn; i++ {
+		for i := range nIn {
 			in[i] = t.In(i)
 		}
-		for i := 0; i < nOut; i++ {
+		for i := range nOut {
 			out[i] = t.Out(i)
 		}
 		ret = reflect.FuncOf(in, out, t.IsVariadic())
 	case reflect.Interface:
 		// not supported
-	case reflect.Ptr:
-		ret = reflect.PtrTo(t.Elem())
+	case reflect.Pointer:
+		ret = reflect.PointerTo(t.Elem())
 	case reflect.Slice:
 		ret = reflect.SliceOf(t.Elem())
 	case reflect.Struct:
@@ -72,7 +72,7 @@ func Underlying(t reflect.Type) (ret reflect.Type) {
 		}()
 		n := t.NumField()
 		fields := make([]reflect.StructField, n)
-		for i := 0; i < n; i++ {
+		for i := range n {
 			fields[i] = t.Field(i)
 		}
 		ret = reflect.StructOf(fields)