working on nesting types

gopherjs · grantnelson-wf · Apr 15, 2025 · Apr 23, 2025 · Apr 24, 2025 · Apr 25, 2025
commit 963fe43e02d0a1750af48c1f040ed91659c06f8c
diff --git a/compiler/internal/typeparams/collect.go b/compiler/internal/typeparams/collect.go
@@ -156,16 +156,16 @@ func (c *visitor) Visit(n ast.Node) (w ast.Visitor) {
 		return
 	}
 
-	if instance, ok := c.info.Instances[ident]; ok {
+	if inst, ok := c.info.Instances[ident]; ok {
 		// Found instance of a generic type or function.
 		obj := c.info.ObjectOf(ident)
-		c.addInstance(obj, instance.TypeArgs)
+		c.addInstance(obj, inst.TypeArgs)
 		return
 	}
 
 	if len(c.resolver.TypeArgs()) > 0 {
-		if obj, ok := c.info.Uses[ident]; ok {
-			// Found instance of a concrete type or function in a generic context.
+		if obj, ok := c.info.Defs[ident]; ok && isConcreteType(obj) {
+			// Found instance of a concrete type defined inside a generic context.
 			c.addInstance(obj, nil)
 			return
 		}
@@ -174,6 +174,20 @@ func (c *visitor) Visit(n ast.Node) (w ast.Visitor) {
 	return
 }
 
+// isConcreteType returns true if the object is a non-generic named type.
+func isConcreteType(obj types.Object) bool {
+	if obj == nil {
+		return false
+	}
+	typ := obj.Type()
+	if ptr, ok := typ.(*types.Pointer); ok {
+		typ = ptr.Elem()
+	}
+
+	t, ok := typ.(*types.Named)
+	return ok && t.TypeParams().Len() == 0
+}
+
 func (c *visitor) addInstance(obj types.Object, tArgs *types.TypeList) {
 	// For types embedded in structs, the object the identifier resolves to is a
 	// *types.Var representing the implicitly declared struct field. However, the
@@ -297,6 +311,7 @@ func (c *Collector) Scan(pkg *types.Package, files ...*ast.File) {
 
 	for iset := c.Instances.Pkg(pkg); !iset.exhausted(); {
 		inst, _ := iset.next()
+
 		switch typ := inst.Object.Type().(type) {
 		case *types.Signature:
 			tParams := SignatureTypeParams(typ)
@@ -306,14 +321,22 @@ func (c *Collector) Scan(pkg *types.Package, files ...*ast.File) {
 				info:      c.Info,
 			}
 			ast.Walk(&v, objMap[inst.Object])
+
 		case *types.Named:
 			obj := typ.Obj()
+			node := objMap[obj]
+			if node == nil {
+				// Types without an entry in objMap are concrete types
+				// that are defined in a generic context. Skip them.
+				continue
+			}
+
 			v := visitor{
 				instances: c.Instances,
 				resolver:  NewResolver(c.TContext, typ.TypeParams(), inst.TArgs, nil),
 				info:      c.Info,
 			}
-			ast.Walk(&v, objMap[obj])
+			ast.Walk(&v, node)
 		}
 	}
 }
diff --git a/compiler/internal/typeparams/instance.go b/compiler/internal/typeparams/instance.go
@@ -3,6 +3,7 @@ package typeparams
 import (
 	"fmt"
 	"go/types"
+	"strings"
 
 	"github.com/gopherjs/gopherjs/compiler/internal/symbol"
 	"github.com/gopherjs/gopherjs/compiler/typesutil"
@@ -54,21 +55,19 @@ func (i *Instance) qualifiedName() string {
 func (i *Instance) typeParamsString(open, close string) string {
 	hasNest := len(i.TNest) > 0
 	hasArgs := len(i.TArgs) > 0
-	tArgs := ""
+	buf := strings.Builder{}
 	if hasNest || hasArgs {
-		tArgs = open
+		buf.WriteString(open)
 		if hasNest {
-			tArgs += i.TNest.String()
-			if hasArgs {
-				tArgs += ";"
-			}
+			buf.WriteString(i.TNest.String())
+			buf.WriteRune(';')
 		}
 		if hasArgs {
-			tArgs += i.TArgs.String()
+			buf.WriteString(i.TArgs.String())
 		}
-		tArgs += close
+		buf.WriteString(close)
 	}
-	return tArgs
+	return buf.String()
 }
 
 // IsTrivial returns true if this is an instance of a non-generic object.

diff --git a/internal/govendor/subst/export.go b/internal/govendor/subst/export.go
@@ -3,7 +3,10 @@
 // type arguments.
 package subst
 
-import "go/types"
+import (
+	"fmt"
+	"go/types"
+)
 
 // To simplify future updates of the borrowed code, we minimize modifications
 // to it as much as possible. This file implements an exported interface to the
@@ -16,7 +19,9 @@ type Subster struct {
 
 // New creates a new Subster with a given list of type parameters and matching args.
 func New(tc *types.Context, tParams *types.TypeParamList, tArgs []types.Type) *Subster {
-	assert(tParams.Len() == len(tArgs), "New() argument count must match")
+	if tParams.Len() != len(tArgs) {
+		panic(fmt.Errorf(`New() argument count must match (%d != %d)`, tParams.Len(), len(tArgs)))
+	}
 
 	if tParams.Len() == 0 && len(tArgs) == 0 {
 		return nil