gopherjs · grantnelson-wf · Apr 15, 2025 · Apr 23, 2025 · Apr 24, 2025 · Apr 25, 2025
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
@@ -5,6 +5,7 @@ import (
 	"go/types"
 	"regexp"
 	"sort"
+	"strings"
 	"testing"
 	"time"
 
@@ -749,6 +750,152 @@ func TestArchiveSelectionAfterSerialization(t *testing.T) {
 	}
 }
 
+func TestNestedConcreteTypeInGenericFunc(t *testing.T) {
+	// This is a test of a type defined inside a generic function
+	// that uses the type parameter of the function as a field type.
+	// The `T` type is unique for each instance of `F`.
+	// The use of `A` as a field is do demonstrate the difference in the types
+	// however even if T had no fields, the type would still be different.
+	//
+	// Change `print(F[?]())` to `fmt.Printf("%T\n", F[?]())` for
+	// golang playground to print the type of T in the different F instances.
+	// (I just didn't want this test to depend on `fmt` when it doesn't need to.)
+
+	src := `
+		package main
+
+		func F[A any]() any {
+			type T struct{
+				a A
+			}
+			return T{}
+		}
+
+		func main() {
+			type Int int
+
+			print(F[int]())
+			print(F[Int]())
+		}
+		`
+
+	srcFiles := []srctesting.Source{{Name: `main.go`, Contents: []byte(src)}}
+	root := srctesting.ParseSources(t, srcFiles, nil)
+	archives := compileProject(t, root, false)
+	mainPkg := archives[root.PkgPath]
+	insts := collectDeclInstances(t, mainPkg)
+
+	exp := []string{
+		`F[int]`,
+		`F[main.Int]`,  // Go prints `F[main.Int·2]`
+		`T[int;]`,      // `T` from `F[int]`      (Go prints `T[int]`)
+		`T[main.Int;]`, // `T` from `F[main.Int]` (Go prints `T[main.Int·2]`)
+	}
+	if diff := cmp.Diff(exp, insts); len(diff) > 0 {
+		t.Errorf("the instances of generics are different:\n%s", diff)
+	}
+}
+
+func TestNestedGenericTypeInGenericFunc(t *testing.T) {
+	// This is a subset of the type param nested test from the go repo.
+	// See https://github.com/golang/go/blob/go1.19.13/test/typeparam/nested.go
+	// The test is failing because nested types aren't being typed differently.
+	// For example the type of `T[int]` below is different based on `F[X]`
+	// instance for different `X` type parameters, hence Go prints the type as
+	// `T[X;int]` instead of `T[int]`.
+
+	src := `
+		package main
+
+		func F[A any]() any {
+			type T[B any] struct{
+				a A
+				b B
+			}
+			return T[int]{}
+		}
+
+		func main() {
+			type Int int
+
+			print(F[int]())
+			print(F[Int]())
+		}
+		`
+
+	srcFiles := []srctesting.Source{{Name: `main.go`, Contents: []byte(src)}}
+	root := srctesting.ParseSources(t, srcFiles, nil)
+	archives := compileProject(t, root, false)
+	mainPkg := archives[root.PkgPath]
+	insts := collectDeclInstances(t, mainPkg)
+
+	exp := []string{
+		`F[int]`,
+		`F[main.Int]`,
+		`T[int;int]`,
+		`T[main.Int;int]`,
+	}
+	if diff := cmp.Diff(exp, insts); len(diff) > 0 {
+		t.Errorf("the instances of generics are different:\n%s", diff)
+	}
+}
+
+func TestNestedGenericTypeInGenericFuncWithSharedTArgs(t *testing.T) {
+	src := `
+		package main
+
+		func F[A any]() any {
+			type T[B any] struct {
+				b B
+			}
+			return T[A]{}
+		}
+
+		func main() {
+			type Int int
+
+			print(F[int]())
+			print(F[Int]())
+		}`
+
+	srcFiles := []srctesting.Source{{Name: `main.go`, Contents: []byte(src)}}
+	root := srctesting.ParseSources(t, srcFiles, nil)
+	archives := compileProject(t, root, false)
+	mainPkg := archives[root.PkgPath]
+	insts := collectDeclInstances(t, mainPkg)
+
+	exp := []string{
+		`F[int]`,
+		`F[main.Int]`,
+		`T[int;int]`,
+		`T[main.Int;main.Int]`,
+		// Make sure that T[int;main.Int] and T[main.Int;int] aren't created.
+	}
+	if diff := cmp.Diff(exp, insts); len(diff) > 0 {
+		t.Errorf("the instances of generics are different:\n%s", diff)
+	}
+}
+
+func collectDeclInstances(t *testing.T, pkg *Archive) []string {
+	t.Helper()
+
+	// Regex to match strings like `Foo[42 /* bar */] =` and capture
+	// the name (`Foo`), the index (`42`), and the instance type (`bar`).
+	rex := regexp.MustCompile(`^\s*(\w+)\s*\[\s*(\d+)\s*\/\*(.+)\*\/\s*\]\s*\=`)
+
+	// Collect all instances of generics (e.g. `Foo[bar] @ 2`) written to the decl code.
+	insts := []string{}
+	for _, decl := range pkg.Declarations {
+		if match := rex.FindAllStringSubmatch(string(decl.DeclCode), 1); len(match) > 0 {
+			instance := match[0][1] + `[` + strings.TrimSpace(match[0][3]) + `]`
+			instance = strings.ReplaceAll(instance, `command-line-arguments`, pkg.Name)
+			insts = append(insts, instance)
+		}
+	}
+	sort.Strings(insts)
+	return insts
+}
+
 func compareOrder(t *testing.T, sourceFiles []srctesting.Source, minify bool) {
 	t.Helper()
 	outputNormal := compile(t, sourceFiles, minify)

diff --git a/compiler/decls.go b/compiler/decls.go
@@ -264,7 +264,7 @@ func (fc *funcContext) newVarDecl(init *types.Initializer) *Decl {
 		fc.localVars = nil // Clean up after ourselves.
 	})
 
-	d.Dce().SetName(init.Lhs[0])
+	d.Dce().SetName(init.Lhs[0], nil, nil)
 	if len(init.Lhs) != 1 || analysis.HasSideEffect(init.Rhs, fc.pkgCtx.Info.Info) {
 		d.Dce().SetAsAlive()
 	}
@@ -291,7 +291,7 @@ func (fc *funcContext) funcDecls(functions []*ast.FuncDecl) ([]*Decl, error) {
 				FullName: funcVarDeclFullName(o),
 				Vars:     []string{objName},
 			}
-			varDecl.Dce().SetName(o)
+			varDecl.Dce().SetName(o, nil, nil)
 			if o.Type().(*types.Signature).TypeParams().Len() != 0 {
 				varDecl.DeclCode = fc.CatchOutput(0, func() {
 					fc.Printf("%s = {};", objName)
@@ -331,7 +331,7 @@ func (fc *funcContext) newFuncDecl(fun *ast.FuncDecl, inst typeparams.Instance)
 		Blocking:    fc.pkgCtx.IsBlocking(inst),
 		LinkingName: symbol.New(o),
 	}
-	d.Dce().SetName(o, inst.TArgs...)
+	d.Dce().SetName(o, inst.TNest, inst.TArgs)
 
 	if typesutil.IsMethod(o) {
 		recv := typesutil.RecvType(o.Type().(*types.Signature)).Obj()
@@ -433,7 +433,8 @@ func (fc *funcContext) newNamedTypeVarDecl(obj *types.TypeName) *Decl {
 		FullName: typeVarDeclFullName(obj),
 		Vars:     []string{name},
 	}
-	if typeparams.HasTypeParams(obj.Type()) {
+
+	if fc.pkgCtx.instanceSet.Pkg(obj.Pkg()).ObjHasInstances(obj) {
 		varDecl.DeclCode = fc.CatchOutput(0, func() {
 			fc.Printf("%s = {};", name)
 		})
@@ -451,23 +452,35 @@ func (fc *funcContext) newNamedTypeVarDecl(obj *types.TypeName) *Decl {
 func (fc *funcContext) newNamedTypeInstDecl(inst typeparams.Instance) (*Decl, error) {
 	originType := inst.Object.Type().(*types.Named)
 
-	fc.typeResolver = typeparams.NewResolver(fc.pkgCtx.typesCtx, typeparams.ToSlice(originType.TypeParams()), inst.TArgs)
+	var nestResolver *typeparams.Resolver
+	if len(inst.TNest) > 0 {
+		fn := typeparams.FindNestingFunc(inst.Object)
+		tp := typeparams.SignatureTypeParams(fn.Type().(*types.Signature))
+		nestResolver = typeparams.NewResolver(fc.pkgCtx.typesCtx, tp, inst.TNest, nil)
+	}
+	fc.typeResolver = typeparams.NewResolver(fc.pkgCtx.typesCtx, originType.TypeParams(), inst.TArgs, nestResolver)
 	defer func() { fc.typeResolver = nil }()
 
 	instanceType := originType
 	if !inst.IsTrivial() {
-		instantiated, err := types.Instantiate(fc.pkgCtx.typesCtx, originType, inst.TArgs, true)
-		if err != nil {
-			return nil, fmt.Errorf("failed to instantiate type %v with args %v: %w", originType, inst.TArgs, err)
+		if len(inst.TArgs) > 0 {
+			instantiated, err := types.Instantiate(fc.pkgCtx.typesCtx, originType, inst.TArgs, true)
+			if err != nil {
+				return nil, fmt.Errorf("failed to instantiate type %v with args %v: %w", originType, inst.TArgs, err)
+			}
+			instanceType = instantiated.(*types.Named)
+		}
+		if len(inst.TNest) > 0 {
+			instantiated := nestResolver.Substitute(instanceType)
+			instanceType = instantiated.(*types.Named)
 		}
-		instanceType = instantiated.(*types.Named)
 	}
 
 	underlying := instanceType.Underlying()
 	d := &Decl{
 		FullName: typeDeclFullName(inst),
 	}
-	d.Dce().SetName(inst.Object, inst.TArgs...)
+	d.Dce().SetName(inst.Object, inst.TNest, inst.TArgs)
 	fc.pkgCtx.CollectDCEDeps(d, func() {
 		// Code that declares a JS type (i.e. prototype) for each Go type.
 		d.DeclCode = fc.CatchOutput(0, func() {
@@ -541,7 +554,8 @@ func (fc *funcContext) structConstructor(t *types.Struct) string {
 	// If no arguments were passed, zero-initialize all fields.
 	fmt.Fprintf(constructor, "\t\tif (arguments.length === 0) {\n")
 	for i := 0; i < t.NumFields(); i++ {
-		fmt.Fprintf(constructor, "\t\t\tthis.%s = %s;\n", fieldName(t, i), fc.translateExpr(fc.zeroValue(t.Field(i).Type())).String())
+		zeroValue := fc.zeroValue(fc.fieldType(t, i))
+		fmt.Fprintf(constructor, "\t\t\tthis.%s = %s;\n", fieldName(t, i), fc.translateExpr(zeroValue).String())
 	}
 	fmt.Fprintf(constructor, "\t\t\treturn;\n")
 	fmt.Fprintf(constructor, "\t\t}\n")
@@ -591,7 +605,7 @@ func (fc *funcContext) anonTypeDecls(anonTypes []*types.TypeName) []*Decl {
 			FullName: anonTypeDeclFullName(t),
 			Vars:     []string{t.Name()},
 		}
-		d.Dce().SetName(t)
+		d.Dce().SetName(t, nil, nil)
 		fc.pkgCtx.CollectDCEDeps(d, func() {
 			d.DeclCode = []byte(fmt.Sprintf("\t%s = $%sType(%s);\n", t.Name(), strings.ToLower(typeKind(t.Type())[5:]), fc.initArgs(t.Type())))
 		})

diff --git a/compiler/expressions.go b/compiler/expressions.go
@@ -178,18 +178,18 @@ func (fc *funcContext) translateExpr(expr ast.Expr) *expression {
 			}
 			if !isKeyValue {
 				for i, element := range e.Elts {
-					elements[i] = fc.translateImplicitConversionWithCloning(element, t.Field(i).Type()).String()
+					elements[i] = fc.translateImplicitConversionWithCloning(element, fc.fieldType(t, i)).String()
 				}
 			}
 			if isKeyValue {
 				for i := range elements {
-					elements[i] = fc.translateExpr(fc.zeroValue(t.Field(i).Type())).String()
+					elements[i] = fc.translateExpr(fc.zeroValue(fc.fieldType(t, i))).String()
 				}
 				for _, element := range e.Elts {
 					kve := element.(*ast.KeyValueExpr)
 					for j := range elements {
 						if kve.Key.(*ast.Ident).Name == t.Field(j).Name() {
-							elements[j] = fc.translateImplicitConversionWithCloning(kve.Value, t.Field(j).Type()).String()
+							elements[j] = fc.translateImplicitConversionWithCloning(kve.Value, fc.fieldType(t, j)).String()
 							break
 						}
 					}
@@ -591,7 +591,7 @@ func (fc *funcContext) translateExpr(expr ast.Expr) *expression {
 		case types.MethodVal:
 			return fc.formatExpr(`$methodVal(%s, "%s")`, fc.makeReceiver(e), sel.Obj().(*types.Func).Name())
 		case types.MethodExpr:
-			fc.pkgCtx.DeclareDCEDep(sel.Obj(), inst.TArgs...)
+			fc.pkgCtx.DeclareDCEDep(sel.Obj(), inst.TNest, inst.TArgs)
 			if _, ok := sel.Recv().Underlying().(*types.Interface); ok {
 				return fc.formatExpr(`$ifaceMethodExpr("%s")`, sel.Obj().(*types.Func).Name())
 			}
@@ -801,7 +801,7 @@ func (fc *funcContext) translateExpr(expr ast.Expr) *expression {
 			switch t := exprType.Underlying().(type) {
 			case *types.Basic:
 				if t.Kind() != types.UnsafePointer {
-					panic("unexpected basic type")
+					panic(fmt.Errorf(`unexpected basic type: %v in %v`, t, e.Name))
 				}
 				return fc.formatExpr("0")
 			case *types.Slice, *types.Pointer:
@@ -906,7 +906,7 @@ func (fc *funcContext) delegatedCall(expr *ast.CallExpr) (callable *expression,
 func (fc *funcContext) makeReceiver(e *ast.SelectorExpr) *expression {
 	sel, _ := fc.selectionOf(e)
 	if !sel.Obj().Exported() {
-		fc.pkgCtx.DeclareDCEDep(sel.Obj())
+		fc.pkgCtx.DeclareDCEDep(sel.Obj(), nil, nil)
 	}
 
 	x := e.X
@@ -917,7 +917,7 @@ func (fc *funcContext) makeReceiver(e *ast.SelectorExpr) *expression {
 				recvType = ptr.Elem()
 			}
 			s := recvType.Underlying().(*types.Struct)
-			recvType = s.Field(index).Type()
+			recvType = fc.fieldType(s, index)
 		}
 
 		fakeSel := &ast.SelectorExpr{X: x, Sel: ast.NewIdent("o")}
@@ -1314,12 +1314,13 @@ func (fc *funcContext) loadStruct(array, target string, s *types.Struct) string
 	var collectFields func(s *types.Struct, path string)
 	collectFields = func(s *types.Struct, path string) {
 		for i := 0; i < s.NumFields(); i++ {
-			field := s.Field(i)
-			if fs, isStruct := field.Type().Underlying().(*types.Struct); isStruct {
-				collectFields(fs, path+"."+fieldName(s, i))
+			fieldName := path + "." + fieldName(s, i)
+			fieldType := fc.fieldType(s, i)
+			if fs, isStruct := fieldType.Underlying().(*types.Struct); isStruct {
+				collectFields(fs, fieldName)
 				continue
 			}
-			fields = append(fields, types.NewVar(0, nil, path+"."+fieldName(s, i), field.Type()))
+			fields = append(fields, types.NewVar(0, nil, fieldName, fieldType))
 		}
 	}
 	collectFields(s, target)

diff --git a/compiler/functions.go b/compiler/functions.go
@@ -49,9 +49,9 @@ func (fc *funcContext) nestedFunctionContext(info *analysis.FuncInfo, inst typep
 	}
 
 	if sig.TypeParams().Len() > 0 {
-		c.typeResolver = typeparams.NewResolver(c.pkgCtx.typesCtx, typeparams.ToSlice(sig.TypeParams()), inst.TArgs)
+		c.typeResolver = typeparams.NewResolver(c.pkgCtx.typesCtx, sig.TypeParams(), inst.TArgs, nil)
 	} else if sig.RecvTypeParams().Len() > 0 {
-		c.typeResolver = typeparams.NewResolver(c.pkgCtx.typesCtx, typeparams.ToSlice(sig.RecvTypeParams()), inst.TArgs)
+		c.typeResolver = typeparams.NewResolver(c.pkgCtx.typesCtx, sig.RecvTypeParams(), inst.TArgs, nil)
 	}
 	if c.objectNames == nil {
 		c.objectNames = map[types.Object]string{}

diff --git a/compiler/internal/analysis/info.go b/compiler/internal/analysis/info.go
@@ -126,8 +126,8 @@ func (info *Info) newFuncInfoInstances(fd *ast.FuncDecl) []*FuncInfo {
 	for _, inst := range instances {
 		var resolver *typeparams.Resolver
 		if sig, ok := obj.Type().(*types.Signature); ok {
-			tp := typeparams.ToSlice(typeparams.SignatureTypeParams(sig))
-			resolver = typeparams.NewResolver(info.typeCtx, tp, inst.TArgs)
+			tp := typeparams.SignatureTypeParams(sig)
+			resolver = typeparams.NewResolver(info.typeCtx, tp, inst.TArgs, nil)
 		}
 		fi := info.newFuncInfo(fd, inst.Object, inst.TArgs, resolver)
 		funcInfos = append(funcInfos, fi)

diff --git a/compiler/internal/analysis/info_test.go b/compiler/internal/analysis/info_test.go
@@ -382,6 +382,7 @@ func TestBlocking_Defers_WithMultipleReturns(t *testing.T) {
 	// of which flow control statements (e.g. if-statements) are terminating
 	// or not. Any defers added in a terminating control flow would not
 	// propagate to returns that are not in that block.
+	// See golang.org/x/tools/go/ssa for flow control analysis.
 	//
 	// For now we simply build up the list of defers as we go making
 	// the return on line 31 also blocking.

diff --git a/compiler/internal/dce/collector.go b/compiler/internal/dce/collector.go
@@ -39,8 +39,8 @@ func (c *Collector) CollectDCEDeps(decl Decl, f func()) {
 // The given optional type arguments are used to when the object is a
 // function with type parameters or anytime the object doesn't carry them.
 // If not given, this attempts to get the type arguments from the object.
-func (c *Collector) DeclareDCEDep(o types.Object, tArgs ...types.Type) {
+func (c *Collector) DeclareDCEDep(o types.Object, tNest, tArgs []types.Type) {
 	if c.dce != nil {
-		c.dce.addDep(o, tArgs)
+		c.dce.addDep(o, tNest, tArgs)
 	}
 }