support generic type oveload method

builtin_test.go

@@ -738,7 +738,7 @@ func TestCheckSigFuncExObjects(t *testing.T) {
 		count int
 	}{
 		{"TyOverloadFunc", sigFuncEx(nil, nil, &TyOverloadFunc{objs}), 2},
-		{"TyOverloadMethod", sigFuncEx(nil, nil, &TyOverloadMethod{objs}), 2},
+		{"TyOverloadMethod", sigFuncEx(nil, nil, &TyOverloadMethod{Methods: objs}), 2},
 		{"TyTemplateRecvMethod", sigFuncEx(nil, nil, &TyTemplateRecvMethod{types.NewParam(0, nil, "", tyInt)}), 1},
 		{"TyTemplateRecvMethod", sigFuncEx(nil, nil, &TyTemplateRecvMethod{fn}), 2},
 		{"TyOverloadNamed", sigFuncEx(nil, nil, &TyOverloadNamed{Types: []*types.Named{named}}), 1},

codebuild.go

@@ -1627,7 +1627,7 @@
 					return kind
 				}
 			}
-			if kind := p.method(t, name, aliasName, flag, arg, srcExpr); kind != MemberInvalid {
+			if kind := p.method(t, name, aliasName, flag, arg, srcExpr, t.TypeArgs() != nil); kind != MemberInvalid {
 				return kind
 			}
 			if fstruc {
@@ -1640,7 +1640,7 @@
 		}
 	case *types.Named:
 		named, typ = o, p.getUnderlying(o) // may cause to loadNamed (delay-loaded)
-		if kind := p.method(o, name, aliasName, flag, arg, srcExpr); kind != MemberInvalid {
+		if kind := p.method(o, name, aliasName, flag, arg, srcExpr, o.TypeArgs() != nil); kind != MemberInvalid {
 			return kind
 		}
 		goto retry
@@ -1653,7 +1653,7 @@
 		}
 	case *types.Interface:
 		o.Complete()
-		if kind := p.method(o, name, aliasName, flag, arg, srcExpr); kind != MemberInvalid {
+		if kind := p.method(o, name, aliasName, flag, arg, srcExpr, false); kind != MemberInvalid {
 			return kind
 		}
 	case *types.Basic, *types.Slice, *types.Map, *types.Chan:
@@ -1663,6 +1663,7 @@
 }
 
 type methodList interface {
+	types.Type
 	NumMethods() int
 	Method(i int) *types.Func
 }
@@ -1708,8 +1709,8 @@
 	return true
 }
 
 func (p *CodeBuilder) method(
-	o methodList, name, aliasName string, flag MemberFlag, arg *Element, src ast.Node) (kind MemberKind) {
+	o methodList, name, aliasName string, flag MemberFlag, arg *Element, src ast.Node, namedHasTypeArgs bool) (kind MemberKind) {
 	var found *types.Func
 	var exact bool
 	for i, n := 0, o.NumMethods(); i < n; i++ {
@@ -1734,7 +1735,13 @@
 		if autoprop && !methodHasAutoProperty(typ, 0) {
 			return memberBad
 		}
-
+		if namedHasTypeArgs {
+			if t, ok := CheckFuncEx(typ.(*types.Signature)); ok {
+				if m, ok := t.(*TyOverloadMethod); ok && m.IsGeneric() {
+					typ = m.Instantiate(o.(*types.Named))
+				}
+			}
+		}
 		sel := selector(arg, found.Name())
 		ret := &internal.Elem{Val: sel, Src: src}
 		if t, set := p.methodSigOf(typ, flag, arg, ret); set {

func_ext.go

@@ -175,19 +175,58 @@
 
 // TyOverloadMethod: overload function type
 type TyOverloadMethod struct {
-	Methods []types.Object
+	Methods  []types.Object
+	indexs   []int                             // func object indexs
+	instance map[*types.Named]*types.Signature // cache type signature for named
 }
 
 func (p *TyOverloadMethod) At(i int) types.Object { return p.Methods[i] }
 func (p *TyOverloadMethod) Len() int              { return len(p.Methods) }
 
 func (p *TyOverloadMethod) Underlying() types.Type { return p }
 func (p *TyOverloadMethod) String() string         { return "TyOverloadMethod" }
 func (p *TyOverloadMethod) funcEx()                {}
 
-// NewOverloadMethod creates an overload method.
-func NewOverloadMethod(typ *types.Named, pos token.Pos, pkg *types.Package, name string, methods ...types.Object) *types.Func {
-	return newMethodEx(typ, pos, pkg, name, &TyOverloadMethod{methods})
+func NewOverloadMethod(typ *types.Named, pos token.Pos, pkg *types.Package, name string, objectIndex map[types.Object]int, methods ...types.Object) *types.Func {
+	t := &TyOverloadMethod{Methods: methods}
+	if typ.TypeParams() != nil {
+		t.indexs = make([]int, len(methods))
+		for i, obj := range methods {
+			t.indexs[i] = objectIndex[obj]
+		}
+		t.instance = make(map[*types.Named]*types.Signature)
+	}
+	return newMethodEx(typ, pos, pkg, name, t)
+}
+
+func (m *TyOverloadMethod) IsGeneric() bool {
+	return len(m.indexs) != 0
+}
+
+func (m *TyOverloadMethod) Instantiate(named *types.Named) *types.Signature {
+	sig, ok := m.instance[named]
+	if !ok {
+		sig = newOverloadMethodType(named, m)
+		m.instance[named] = sig
+	}
+	return sig
+}
+
+func newOverloadMethodType(named *types.Named, m *TyOverloadMethod) *types.Signature {
+	var list methodList
+	switch t := named.Underlying().(type) {
+	case *types.Interface:
+		list = t
+	default:
+		list = named
+	}
+	pkg := named.Obj().Pkg()
+	recv := types.NewVar(token.NoPos, pkg, "", named)
+	methods := make([]types.Object, len(m.indexs))
+	for i, index := range m.indexs {
+		methods[i] = list.Method(index)
+	}
+	return sigFuncEx(pkg, recv, &TyOverloadMethod{Methods: methods})
 }
 
 // CheckOverloadMethod checks a func is overload method or not.

import.go

@@ -105,6 +105,7 @@ func InitThisGopPkgEx(pkg *types.Package, pos map[string]token.Pos) {
 	scope := pkg.Scope()
 	gopos := make([]string, 0, 4)
 	overloads := make(map[omthd][]types.Object)
+	mobjectIndexs := make(map[types.Object]int)
 	onameds := make(map[string][]*types.Named)
 	names := scope.Names()
 	for _, name := range names {
@@ -131,6 +132,7 @@ func InitThisGopPkgEx(pkg *types.Package, pos map[string]token.Pos) {
 					mthd := mName[:len(mName)-3]
 					key := omthd{named, mthd}
 					overloads[key] = append(overloads[key], m)
+					mobjectIndexs[m] = i
 				}
 			}
 			if isOverload(name) { // overload named
@@ -161,15 +163,15 @@ func InitThisGopPkgEx(pkg *types.Package, pos map[string]token.Pos) {
 				}
 			}
 			if len(fns) > 0 {
-				newOverload(pkg, scope, m, fns, pos)
+				newOverload(pkg, scope, m, fns, pos, nil)
 			}
 			delete(overloads, m)
 		}
 	}
 	for key, items := range overloads {
 		off := len(key.name) + 2
 		fns := overloadFuncs(off, items)
-		newOverload(pkg, scope, key, fns, pos)
+		newOverload(pkg, scope, key, fns, pos, mobjectIndexs)
 	}
 	for name, items := range onameds {
 		off := len(name) + 2
@@ -315,7 +317,7 @@ func checkOverloads(scope *types.Scope, gopoName string) (ret []string, exists b
 	return
 }
 
-func newOverload(pkg *types.Package, scope *types.Scope, m omthd, fns []types.Object, pos map[string]token.Pos) {
+func newOverload(pkg *types.Package, scope *types.Scope, m omthd, fns []types.Object, pos map[string]token.Pos, mobjectIndexs map[types.Object]int) {
 	if m.typ == nil {
 		if debugImport {
 			log.Println("==> NewOverloadFunc", m.name)
@@ -327,7 +329,7 @@ func newOverload(pkg *types.Package, scope *types.Scope, m omthd, fns []types.Ob
 		if debugImport {
 			log.Println("==> NewOverloadMethod", m.typ.Obj().Name(), m.name)
 		}
-		NewOverloadMethod(m.typ, pos[m.typ.Obj().Name()+"."+m.name], pkg, m.name, fns...)
+		NewOverloadMethod(m.typ, pos[m.typ.Obj().Name()+"."+m.name], pkg, m.name, mobjectIndexs, fns...)
 	}
 }
 

internal/foo/foo.go

@@ -116,4 +116,36 @@
 	Attr__1(k, v string) (ret NodeSeter)
 }
 
+type Data[T any] struct {
+	data []T
+}
+
+func (p *Data[T]) Size() int {
+	return len(p.data)
+}
+
+func (p *Data[T]) Add__0(v ...T) {
+	p.data = append(p.data, v...)
+}
+
+func (p *Data[T]) Add__1(v Data[T]) {
+	p.data = append(p.data, v.data...)
+}
+
+func (p *Data[T]) IndexOf__0(v T) int {
+	return -1
+}
+
+func (p *Data[T]) IndexOf__1(pos int, v T) int {
+	return -1
+}
+
+type DataInterface[T any] interface {
+	Size() int
+	Add__0(v ...T)
+	Add__1(v DataInterface[T])
+	IndexOf__0(v T) int
+	IndexOf__1(pos int, v T) int
+}
+
 // -----------------------------------------------------------------------------

typeparams_test.go

@@ -1190,3 +1190,87 @@
 }
 `)
 }
+
+func TestGenericTypeOverloadMethod(t *testing.T) {
+	pkg := newMainPackage()
+	foo := pkg.Import("github.com/goplus/gogen/internal/foo")
+	tyDataT := foo.Ref("Data").Type()
+	tyInt := types.Typ[types.Int]
+	tyData, _ := types.Instantiate(nil, tyDataT, []types.Type{tyInt}, true)
+	v := pkg.NewParam(token.NoPos, "v", tyData)
+	pkg.NewFunc(nil, "bar", types.NewTuple(v), nil, false).BodyStart(pkg).
+		DefineVarStart(token.NoPos, "n").Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("size", gogen.MemberFlagMethodAlias)
+		}).
+		Call(0).EndInit(1).EndStmt().
+		Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("add", gogen.MemberFlagMethodAlias)
+		}).
+		Val(0).Val(1).Call(2).EndStmt().
+		Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("add", gogen.MemberFlagMethodAlias)
+		}).
+		Val(v).Call(1).EndStmt().
+		DefineVarStart(token.NoPos, "i").Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("indexOf", gogen.MemberFlagMethodAlias)
+		}).
+		Val(0).Val(1).Call(2).EndInit(1).EndStmt().
+		End()
+	domTest(t, pkg, `package main
+
+import "github.com/goplus/gogen/internal/foo"
+
+func bar(v foo.Data[int]) {
+	n := v.Size()
+	v.Add__0(0, 1)
+	v.Add__1(v)
+	i := v.IndexOf__1(0, 1)
+}
+`)
+}
+
+func TestGenericInterfaceOverloadMethod(t *testing.T) {
+	pkg := newMainPackage()
+	foo := pkg.Import("github.com/goplus/gogen/internal/foo")
+	tyDataT := foo.Ref("DataInterface").Type()
+	tyInt := types.Typ[types.Int]
+	tyData, _ := types.Instantiate(nil, tyDataT, []types.Type{tyInt}, true)
+	v := pkg.NewParam(token.NoPos, "v", tyData)
+	pkg.NewFunc(nil, "bar", types.NewTuple(v), nil, false).BodyStart(pkg).
+		DefineVarStart(token.NoPos, "n").Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("size", gogen.MemberFlagMethodAlias)
+		}).
+		Call(0).EndInit(1).EndStmt().
+		Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("add", gogen.MemberFlagMethodAlias)
+		}).
+		Val(0).Val(1).Call(2).EndStmt().
+		Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("add", gogen.MemberFlagMethodAlias)
+		}).
+		Val(v).Call(1).EndStmt().
+		DefineVarStart(token.NoPos, "i").Val(v).
+		Debug(func(cb *gogen.CodeBuilder) {
+			cb.Member("indexOf", gogen.MemberFlagMethodAlias)
+		}).
+		Val(0).Val(1).Call(2).EndInit(1).EndStmt().
+		End()
+	domTest(t, pkg, `package main
+
+import "github.com/goplus/gogen/internal/foo"
+
+func bar(v foo.DataInterface[int]) {
+	n := v.Size()
+	v.Add__0(0, 1)
+	v.Add__1(v)
+	i := v.IndexOf__1(0, 1)
+}
+`)
+}