feat: add alias resolution function

Signed-off-by: Mark Sagi-Kazar <[email protected]>

Author: sagikazarmark

alias.go

@@ -0,0 +1,69 @@
+// Copyright © 2014 Steve Francia <[email protected]>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+package cast
+
+import (
+	"reflect"
+	"slices"
+)
+
+var kindNames = []string{
+	reflect.String:  "string",
+	reflect.Bool:    "bool",
+	reflect.Int:     "int",
+	reflect.Int8:    "int8",
+	reflect.Int16:   "int16",
+	reflect.Int32:   "int32",
+	reflect.Int64:   "int64",
+	reflect.Uint:    "uint",
+	reflect.Uint8:   "uint8",
+	reflect.Uint16:  "uint16",
+	reflect.Uint32:  "uint32",
+	reflect.Uint64:  "uint64",
+	reflect.Float32: "float32",
+	reflect.Float64: "float64",
+}
+
+var kinds = map[reflect.Kind]func(reflect.Value) any{
+	reflect.String:  func(v reflect.Value) any { return v.String() },
+	reflect.Bool:    func(v reflect.Value) any { return v.Bool() },
+	reflect.Int:     func(v reflect.Value) any { return int(v.Int()) },
+	reflect.Int8:    func(v reflect.Value) any { return int8(v.Int()) },
+	reflect.Int16:   func(v reflect.Value) any { return int16(v.Int()) },
+	reflect.Int32:   func(v reflect.Value) any { return int32(v.Int()) },
+	reflect.Int64:   func(v reflect.Value) any { return v.Int() },
+	reflect.Uint:    func(v reflect.Value) any { return uint(v.Uint()) },
+	reflect.Uint8:   func(v reflect.Value) any { return uint8(v.Uint()) },
+	reflect.Uint16:  func(v reflect.Value) any { return uint16(v.Uint()) },
+	reflect.Uint32:  func(v reflect.Value) any { return uint32(v.Uint()) },
+	reflect.Uint64:  func(v reflect.Value) any { return v.Uint() },
+	reflect.Float32: func(v reflect.Value) any { return float32(v.Float()) },
+	reflect.Float64: func(v reflect.Value) any { return v.Float() },
+}
+
+// resolveAlias attempts to resolve a named type to its underlying basic type (if possible).
+//
+// Pointers are expected to be indirected by this point.
+func resolveAlias(i any) (any, bool) {
+	if i == nil {
+		return nil, false
+	}
+
+	t := reflect.TypeOf(i)
+
+	// Not a named type
+	if t.Name() == "" || slices.Contains(kindNames, t.Name()) {
+		return i, false
+	}
+
+	resolve, ok := kinds[t.Kind()]
+	if !ok { // Not a supported kind
+		return i, false
+	}
+
+	v := reflect.ValueOf(i)
+
+	return resolve(v), true
+}

alias_test.go

@@ -0,0 +1,82 @@
+// Copyright © 2014 Steve Francia <[email protected]>.
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file.
+package cast
+
+import (
+	"testing"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestAlias(t *testing.T) {
+	type MyStruct struct{}
+
+	type MyString string
+	type MyOtherString MyString
+	type MyAliasString = MyOtherString
+
+	type MyBool bool
+	type MyOtherBool MyBool
+	type MyAliasBool = MyOtherBool
+
+	type MyInt int
+	type MyInt8 int8
+	type MyInt16 int16
+	type MyInt32 int32
+	type MyInt64 int64
+	type MyUint uint
+	type MyUint8 uint8
+	type MyUint16 uint16
+	type MyUint32 uint32
+	type MyUint64 uint64
+	type MyFloat32 float32
+	type MyFloat64 float64
+
+	testCases := []struct {
+		input         any
+		expectedValue any
+		expectedOk    bool
+	}{
+		{"string", "string", false},     // Already resolved
+		{MyStruct{}, MyStruct{}, false}, // Non-resolvable
+
+		{MyString("string"), "string", true},
+		{MyOtherString("string"), "string", true},
+		{MyAliasString("string"), "string", true},
+
+		{MyBool(true), true, true},
+		{MyOtherBool(true), true, true},
+		{MyAliasBool(true), true, true},
+
+		{MyInt(1234), int(1234), true},
+		{MyInt8(123), int8(123), true},
+		{MyInt16(1234), int16(1234), true},
+		{MyInt32(1234), int32(1234), true},
+		{MyInt64(1234), int64(1234), true},
+
+		{MyUint(1234), uint(1234), true},
+		{MyUint8(123), uint8(123), true},
+		{MyUint16(1234), uint16(1234), true},
+		{MyUint32(1234), uint32(1234), true},
+		{MyUint64(1234), uint64(1234), true},
+
+		{MyFloat32(1.0), float32(1.0), true},
+		{MyFloat64(1.0), float64(1.0), true},
+	}
+
+	for _, testCase := range testCases {
+		// TODO: remove after minimum Go version is >=1.22
+		testCase := testCase
+
+		t.Run("", func(t *testing.T) {
+			c := qt.New(t)
+
+			actualValue, ok := resolveAlias(testCase.input)
+
+			c.Assert(actualValue, qt.Equals, testCase.expectedValue)
+			c.Assert(ok, qt.Equals, testCase.expectedOk)
+		})
+	}
+}