Add generics support - type parameters, generic types and functions

Co-authored-by: wzshiming <[email protected]>

Author: Copilot

.github/workflows/go.yml

@@ -14,11 +14,6 @@ jobs:
     strategy:
       matrix:
         go-version:
-          - '1.13'
-          - '1.14'
-          - '1.15'
-          - '1.16'
-          - '1.17'
           - '1.18'
           - '1.19'
           - '1.20'

README.md

@@ -15,10 +15,6 @@ Golang source code parsing, usage like reflect package
 
 [Examples](https://github.com/wzshiming/gotype/blob/master/cmd/pkgimport/main.go)
 
-## TODO
-
-- Supports generics
-
 ## License
 
 Licensed under the MIT License. See [LICENSE](https://github.com/wzshiming/gotype/blob/master/LICENSE) for the full license text.

README_cn.md

@@ -15,10 +15,6 @@ Golang 源代码解析，像反射包一样使用
 
 [示例](https://github.com/wzshiming/gotype/blob/master/cmd/pkgimport/main.go)
 
-## TODO
-
-- 支持泛型
-
 ## 许可证
 
 软包根据MIT License。有关完整的许可证文本，请参阅[LICENSE](https://github.com/wzshiming/gotype/blob/master/LICENSE)。

kind.go

@@ -51,4 +51,5 @@ const (
 	Field       // a Struct Field
 	Scope       // package or func body
 	Declaration // a top-level function, variable, or constant.
+	TypeParam   // a type parameter in a generic type or function
 )

kind_string.go

@@ -15,10 +15,12 @@ func TestOther(t *testing.T) {
 		"github.com/wzshiming/gotype/testdata/kind",
 		"github.com/wzshiming/gotype/testdata/type",
 		"github.com/wzshiming/gotype/testdata/pkg",
+		"github.com/wzshiming/gotype/testdata/generics",
 		"./testdata/value",
 		"./testdata/kind",
 		"./testdata/type",
 		"./testdata/pkg",
+		"./testdata/generics",
 	}
 	for _, src := range testpath {
 		testAll(t, src)
@@ -133,6 +135,20 @@ func testType(t *testing.T, fset *token.FileSet, v Type) {
 					if !ok {
 						t.Fatal(pos, "Error not found: ", to)
 					}
+				case "TypeParam":
+					if len(method) < 2 {
+						t.Fatal(pos, "Error TypeParam num: ", to)
+					}
+					i, err := strconv.ParseInt(method[1], 10, 64)
+					if err != nil {
+						t.Fatal(pos, "Error TypeParam: ", err)
+					}
+					if v.NumTypeParam() <= int(i) {
+						t.Fatal(pos, "Error Out of index range: ", to)
+					}
+					v = v.TypeParam(int(i))
+				case "Constraint":
+					v = v.Constraint()
 				default:
 					t.Fatal(pos, "Error to: ", to)
 				}
@@ -204,5 +220,11 @@ func testType(t *testing.T, fset *token.FileSet, v Type) {
 				t.Fatal(pos, "Error tag:", num, ":", data)
 			}
 		}
+		if data, ok := tag.Lookup("NumTypeParam"); ok {
+			num := fmt.Sprint(v.NumTypeParam())
+			if data != num {
+				t.Fatal(pos, "Error num type param:", num, ":", data)
+			}
+		}
 	}
 }

other_test.go

@@ -101,6 +101,20 @@ func (r *parser) parseType(info *infoFile, decl *ast.GenDecl) {
 		comment := s.Comment
 
 		tt := r.evalType(info, s.Type)
+		
+		// Handle type parameters for generic types
+		if s.TypeParams != nil && s.TypeParams.NumFields() > 0 {
+			typeParams := make([]Type, 0, s.TypeParams.NumFields())
+			for _, field := range s.TypeParams.List {
+				constraint := r.evalType(info, field.Type)
+				for _, name := range field.Names {
+					param := newTypeParam(name.Name, constraint)
+					typeParams = append(typeParams, param)
+				}
+			}
+			tt = newTypeGeneric(tt, typeParams)
+		}
+		
 		if s.Assign == 0 && tt.Kind() != Interface {
 			tt = newTypeNamed(s.Name.Name, tt, info)
 		} else {

parser.go

@@ -68,7 +68,15 @@ func (r *parser) evalType(info *infoFile, expr ast.Expr) (ret Type) {
 		case Array, Chan, Map, Ptr, Slice:
 			return typ.Elem()
 		}
-		return nil
+		return typ
+	case *ast.IndexListExpr:
+		// Generic type instantiation with multiple type arguments
+		// e.g., Pair[string, int]
+		typ := r.evalType(info, t.X)
+		if typ == nil {
+			return nil
+		}
+		return typ
 	case *ast.SliceExpr:
 		return r.evalType(info, t.X)
 	case *ast.TypeAssertExpr:
@@ -180,6 +188,20 @@ func (r *parser) evalType(info *infoFile, expr ast.Expr) (ret Type) {
 		return s
 	case *ast.FuncType:
 		s := &typeFunc{}
+
+		// Handle type parameters for generic functions
+		if t.TypeParams != nil && t.TypeParams.NumFields() > 0 {
+			typeParams := make([]Type, 0, t.TypeParams.NumFields())
+			for _, field := range t.TypeParams.List {
+				constraint := r.evalType(info, field.Type)
+				for _, name := range field.Names {
+					param := newTypeParam(name.Name, constraint)
+					typeParams = append(typeParams, param)
+				}
+			}
+			s.typeParams = typeParams
+		}
+
 		if t.Params != nil {
 			list := t.Params.List
 			for pk, v := range list {

parser_types.go

@@ -0,0 +1,81 @@
+package generics
+
+// Generic type with single type parameter
+// String:"Box[T any]"
+// NumTypeParam:"1"
+// To:"TypeParam:0" Name:"T" Kind:"TypeParam" String:"T any"
+// To:"TypeParam:0,Constraint" Name:"any"
+type Box[T any] struct {
+	Value T
+}
+
+// Generic type with constraint
+// String:"Comparable[T comparable]"
+// NumTypeParam:"1"
+// To:"TypeParam:0" Name:"T" Kind:"TypeParam" String:"T comparable"
+// To:"TypeParam:0,Constraint" Name:"comparable"
+type Comparable[T comparable] struct {
+	Value T
+}
+
+// Generic type with multiple type parameters
+// String:"Pair[K comparable, V any]"
+// NumTypeParam:"2"
+// To:"TypeParam:0" Name:"K" Kind:"TypeParam" String:"K comparable"
+// To:"TypeParam:0,Constraint" Name:"comparable"
+// To:"TypeParam:1" Name:"V" Kind:"TypeParam" String:"V any"
+// To:"TypeParam:1,Constraint" Name:"any"
+type Pair[K comparable, V any] struct {
+	Key   K
+	Value V
+}
+
+// Generic function
+// String:"Max[T comparable]"
+// To:"Declaration" NumTypeParam:"1" String:"func[T comparable](a, b) (_)"
+// To:"Declaration,TypeParam:0" Name:"T" Kind:"TypeParam" String:"T comparable"
+// To:"Declaration,TypeParam:0,Constraint" Name:"comparable"
+func Max[T comparable](a, b T) T {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// Generic function with multiple type parameters
+// String:"Map[K comparable, V any]"
+// To:"Declaration" NumTypeParam:"2" String:"func[K comparable, V any](m, f) (_)"
+// To:"Declaration,TypeParam:0" Name:"K" Kind:"TypeParam" String:"K comparable"
+// To:"Declaration,TypeParam:0,Constraint" Name:"comparable"
+// To:"Declaration,TypeParam:1" Name:"V" Kind:"TypeParam" String:"V any"
+// To:"Declaration,TypeParam:1,Constraint" Name:"any"
+func Map[K comparable, V any](m map[K]V, f func(V) V) map[K]V {
+	result := make(map[K]V)
+	for k, v := range m {
+		result[k] = f(v)
+	}
+	return result
+}
+
+// Custom interface constraint
+type Stringer interface {
+	String() string
+}
+
+// Generic type with custom interface constraint
+// String:"StringableBox[T Stringer]"
+// NumTypeParam:"1"
+// To:"TypeParam:0" Name:"T" Kind:"TypeParam" String:"T Stringer"
+// To:"TypeParam:0,Constraint" Name:"Stringer" Kind:"Interface"
+type StringableBox[T Stringer] struct {
+	Value T
+}
+
+// Generic function with custom interface constraint
+// String:"Stringify[T Stringer]"
+// To:"Declaration" NumTypeParam:"1" String:"func[T Stringer](value) (_)"
+// To:"Declaration,TypeParam:0" Name:"T" Kind:"TypeParam" String:"T Stringer"
+// To:"Declaration,TypeParam:0,Constraint" Name:"Stringer" Kind:"Interface"
+func Stringify[T Stringer](value T) string {
+	return value.String()
+}

testdata/generics/a.go

@@ -163,6 +163,18 @@ type Type interface {
 
 	// Comment returns the type's comment within its package.
 	Comment() *ast.CommentGroup
+
+	// NumTypeParam returns the number of type parameters for a generic type or function.
+	// It returns 0 for non-generic types.
+	NumTypeParam() int
+
+	// TypeParam returns the i'th type parameter.
+	// It panics if i is not in the range [0, NumTypeParam()).
+	TypeParam(int) Type
+
+	// Constraint returns the constraint of a type parameter.
+	// It panics if the type's Kind is not TypeParam.
+	Constraint() Type
 }
 
 type types []Type
@@ -345,3 +357,15 @@ func (t *typeBase) Doc() *ast.CommentGroup {
 func (t *typeBase) Comment() *ast.CommentGroup {
 	return nil
 }
+
+func (t *typeBase) NumTypeParam() int {
+	return 0
+}
+
+func (t *typeBase) TypeParam(int) Type {
+	panic("TypeParam of non-generic type")
+}
+
+func (t *typeBase) Constraint() Type {
+	panic("Constraint of non-type-parameter type")
+}