working on identifying where nesting types should get injected

grantnelson-wf · grantnelson-wf · commit e82fa784c5d1 · 2025-04-23T15:04:16.000-06:00
diff --git a/compiler/compiler_test.go b/compiler/compiler_test.go
@@ -750,8 +750,53 @@ func TestArchiveSelectionAfterSerialization(t *testing.T) {
 	}
 }
 
-func TestNestedTypesDuplicateDecls(t *testing.T) {
-	// This is a subset of the type param nested test.
+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[main.Int·2]`,
+		`F[int]`,
+		`T[main.Int·2]`, // `T` from `F[main.Int·2]`
+		`T[int]`,        // `T` from `F[Int]`
+	}
+	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]`
@@ -761,49 +806,56 @@ func TestNestedTypesDuplicateDecls(t *testing.T) {
 	src := `
 		package main
 
-		type intish interface { ~int }
-
-		func F[A intish]() {
-			type T[B intish] struct{}
-			print(T[int]{})
+		func F[A any]() any {
+			type T[B any] struct{
+				a A
+				b B
+			}
+			return T[int]{}
 		}
 
 		func main() {
 			type Int int
 
-			F[int]()
-			F[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[int]`,
+		`T[Int;int]`,
+		`T[int;int]`,
+	}
+	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 (i.e. `Foo[bar]`) written to the decl code.
+	// Collect all instances of generics (e.g. `Foo[bar]`) written to the decl code.
 	insts := []string{}
-	for _, decl := range mainPkg.Declarations {
+	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.`, ``)
 			insts = append(insts, instance)
 		}
 	}
 	sort.Strings(insts)
-
-	exp := []string{
-		`F[Int]`,
-		`F[int]`,
-		`T[Int;int]`,
-		`T[int;int]`,
-	}
-	if diff := cmp.Diff(exp, insts); len(diff) > 0 {
-		t.Errorf("the instances of generics are different:\n%s", diff)
-	}
+	return insts
 }
 
 func compareOrder(t *testing.T, sourceFiles []srctesting.Source, minify bool) {
diff --git a/compiler/decls.go b/compiler/decls.go
@@ -518,6 +518,9 @@ func (fc *funcContext) newNamedTypeInstDecl(inst typeparams.Instance) (*Decl, er
 		// initialize themselves.
 		switch t := underlying.(type) {
 		case *types.Array, *types.Chan, *types.Interface, *types.Map, *types.Pointer, *types.Slice, *types.Signature, *types.Struct:
+
+			fmt.Printf(">>>[A] (%[1]T): %[1]v\n", t) // TODO(grantnelson-wf): remove
+
 			d.TypeInitCode = fc.CatchOutput(0, func() {
 				fc.Printf("%s.init(%s);", fc.instName(inst), fc.initArgs(t))
 			})
diff --git a/compiler/internal/typeparams/collect.go b/compiler/internal/typeparams/collect.go
@@ -82,6 +82,13 @@ func (r *Resolver) SubstituteSelection(sel typesutil.Selection) typesutil.Select
 	}
 }
 
+func (r *Resolver) String() string { // TODO(grantnelson-wf): remove
+	if r == nil || r.subster == nil {
+		return "<nil Resolver>"
+	}
+	return r.subster.String()
+}
+
 // ToSlice converts TypeParamList into a slice with the same order of entries.
 func ToSlice(tpl *types.TypeParamList) []*types.TypeParam {
 	result := make([]*types.TypeParam, tpl.Len())
@@ -114,10 +121,21 @@ func (c *visitor) Visit(n ast.Node) (w ast.Visitor) {
 	}
 
 	instance, ok := c.info.Instances[ident]
-	if !ok {
+	if ok {
+		c.addNamedInstance(ident, instance)
+		return
+	}
+
+	def, ok := c.info.Defs[ident]
+	if ok && def != nil {
+		c.addNestedNamed(ident, def)
 		return
 	}
 
+	return
+}
+
+func (c *visitor) addNamedInstance(ident *ast.Ident, instance types.Instance) {
 	obj := c.info.ObjectOf(ident)
 
 	// For types embedded in structs, the object the identifier resolves to is a
@@ -145,7 +163,21 @@ func (c *visitor) Visit(n ast.Node) (w ast.Visitor) {
 			})
 		}
 	}
-	return
+
+	fmt.Printf(">>>[X] %s => %v\n", ident.Name, obj) // TODO(grantnelson-wf): remove
+}
+
+// TODO(grantnelson-wf): finish or remove
+func (c *visitor) addNestedNamed(ident *ast.Ident, obj types.Object) {
+	typ := obj.Type()
+	if ptr, ok := typ.(*types.Pointer); ok {
+		typ = ptr.Elem()
+	}
+	if t, ok := typ.(*types.Named); ok {
+		obj = t.Obj()
+	}
+
+	fmt.Printf(">>>[Y] %s => %v\n", ident.Name, obj) // TODO(grantnelson-wf): remove
 }
 
 // seedVisitor implements ast.Visitor that collects information necessary to
@@ -173,11 +205,11 @@ func (c *seedVisitor) Visit(n ast.Node) ast.Visitor {
 		sig := obj.Type().(*types.Signature)
 		if sig.TypeParams().Len() != 0 || sig.RecvTypeParams().Len() != 0 {
 			c.objMap[obj] = n
-			return &seedVisitor{
+			return newPrinter(&seedVisitor{
 				visitor: c.visitor,
 				objMap:  c.objMap,
 				mapOnly: true,
-			}
+			}, "FuncDeclSeed")
 		}
 	case *ast.TypeSpec:
 		obj := c.info.Defs[n.Name]
@@ -236,7 +268,7 @@ func (c *Collector) Scan(pkg *types.Package, files ...*ast.File) {
 		objMap: objMap,
 	}
 	for _, file := range files {
-		ast.Walk(&sc, file)
+		ast.Walk(newPrinter(&sc, "Seed"), file)
 	}
 
 	for iset := c.Instances.Pkg(pkg); !iset.exhausted(); {
@@ -248,15 +280,59 @@ func (c *Collector) Scan(pkg *types.Package, files ...*ast.File) {
 				resolver:  NewResolver(c.TContext, ToSlice(SignatureTypeParams(typ)), inst.TArgs),
 				info:      c.Info,
 			}
-			ast.Walk(&v, objMap[inst.Object])
+			ast.Walk(newPrinter(&v, "Signature"), objMap[inst.Object])
 		case *types.Named:
 			obj := typ.Obj()
 			v := visitor{
 				instances: c.Instances,
 				resolver:  NewResolver(c.TContext, ToSlice(typ.TypeParams()), inst.TArgs),
 				info:      c.Info,
 			}
-			ast.Walk(&v, objMap[obj])
+			ast.Walk(newPrinter(&v, "Named"), objMap[obj])
+		}
+	}
+}
+
+type printer struct { // TODO(grantnelson-wf): remove
+	inner  ast.Visitor
+	title  string
+	indent string
+}
+
+func newPrinter(inner ast.Visitor, title string) *printer {
+	return &printer{
+		inner:  inner,
+		title:  title,
+		indent: ``,
+	}
+}
+
+func (p *printer) Visit(n ast.Node) (w ast.Visitor) {
+	if n == nil {
+		if len(p.indent) >= 2 {
+			p.indent = p.indent[:len(p.indent)-2]
+		}
+	} else {
+		p.indent += "  "
+		if id, ok := n.(*ast.Ident); ok {
+			fmt.Printf("%s%s(%T)%q\n", p.title, p.indent, n, id.Name)
+		} else {
+			fmt.Printf("%s%s(%T)\n", p.title, p.indent, n)
+		}
+	}
+	v2 := p.inner.Visit(n)
+	if v2 != nil {
+		if v2 == p.inner {
+			return p
+		}
+		if _, ok := v2.(*printer); ok {
+			return v2
+		}
+		v2 = &printer{
+			inner:  v2,
+			title:  p.title,
+			indent: p.indent,
 		}
 	}
+	return v2
 }
diff --git a/compiler/internal/typeparams/instance.go b/compiler/internal/typeparams/instance.go
@@ -15,6 +15,11 @@ import (
 type Instance struct {
 	Object types.Object       // Object to be instantiated.
 	TArgs  typesutil.TypeList // Type params to instantiate with.
+
+	// TNest is the type params of the function this object was nested with-in.
+	// e.g. In `func A[X any]() { type B[Y any] struct {} }` the `X`
+	// from `A` is the context of `B[Y]` thus creating `B[X;Y]`.
+	TNest typesutil.TypeList
 }
 
 // String returns a string representation of the Instance.
@@ -32,11 +37,29 @@ func (i *Instance) String() string {
 
 // TypeString returns a Go type string representing the instance (suitable for %T verb).
 func (i *Instance) TypeString() string {
+	return fmt.Sprintf("%s.%s%s", i.Object.Pkg().Name(), i.Object.Name(), i.typeParamsString())
+}
+
+// typeParamsString returns part of a Go type string that represents the type
+// parameters of the instance including the nesting type parameters, e.g. [X;Y,Z].
+func (i *Instance) typeParamsString() string {
+	hasNest := len(i.TNest) > 0
+	hasArgs := len(i.TArgs) > 0
 	tArgs := ""
-	if len(i.TArgs) > 0 {
-		tArgs = "[" + i.TArgs.String() + "]"
+	if hasNest || hasArgs {
+		tArgs = "["
+		if hasNest {
+			tArgs = i.TNest.String()
+			if hasArgs {
+				tArgs += ";"
+			}
+		}
+		if hasArgs {
+			tArgs = i.TArgs.String()
+		}
+		tArgs += "]"
 	}
-	return fmt.Sprintf("%s.%s%s", i.Object.Pkg().Name(), i.Object.Name(), tArgs)
+	return tArgs
 }
 
 // IsTrivial returns true if this is an instance of a non-generic object.
diff --git a/compiler/internal/typeparams/map.go b/compiler/internal/typeparams/map.go
@@ -38,9 +38,11 @@ type InstanceMap[V any] struct {
 // If the given key isn't found, an empty bucket and -1 are returned.
 func (im *InstanceMap[V]) findIndex(key Instance) (mapBucket[V], int) {
 	if im != nil && im.data != nil {
-		bucket := im.data[key.Object][typeHash(im.hasher, key.TArgs...)]
+		bucket := im.data[key.Object][typeHash(im.hasher, key.TNest, key.TArgs)]
 		for i, candidate := range bucket {
-			if candidate != nil && candidate.key.TArgs.Equal(key.TArgs) {
+			if candidate != nil &&
+				candidate.key.TNest.Equal(key.TNest) &&
+				candidate.key.TArgs.Equal(key.TArgs) {
 				return bucket, i
 			}
 		}
@@ -82,15 +84,15 @@ func (im *InstanceMap[V]) Set(key Instance, value V) V {
 	if _, ok := im.data[key.Object]; !ok {
 		im.data[key.Object] = mapBuckets[V]{}
 	}
-	bucketID := typeHash(im.hasher, key.TArgs...)
+	bucketID := typeHash(im.hasher, key.TNest, key.TArgs)
 
 	// If there is already an identical key in the map, override the entry value.
 	hole := -1
 	bucket := im.data[key.Object][bucketID]
 	for i, candidate := range bucket {
 		if candidate == nil {
 			hole = i
-		} else if candidate.key.TArgs.Equal(key.TArgs) {
+		} else if candidate.key.TNest.Equal(key.TNest) && candidate.key.TArgs.Equal(key.TArgs) {
 			old := candidate.value
 			candidate.value = value
 			return old
@@ -185,8 +187,11 @@ func (im *InstanceMap[V]) String() string {
 // Provided hasher is used to compute hashes of individual types, which are
 // xor'ed together. Xor preserves bit distribution property, so the combined
 // hash should be as good for bucketing, as the original.
-func typeHash(hasher typeutil.Hasher, types ...types.Type) uint32 {
+func typeHash(hasher typeutil.Hasher, nestTypes []types.Type, types []types.Type) uint32 {
 	var hash uint32
+	for _, typ := range nestTypes {
+		hash ^= hasher.Hash(typ)
+	}
 	for _, typ := range types {
 		hash ^= hasher.Hash(typ)
 	}
diff --git a/compiler/package.go b/compiler/package.go
@@ -327,7 +327,19 @@ func (fc *funcContext) initArgs(ty types.Type) string {
 		}
 		return fmt.Sprintf(`"%s", [%s]`, pkgPath, strings.Join(fields, ", "))
 	case *types.TypeParam:
-		err := bailout(fmt.Errorf(`%v has unexpected generic type parameter %T`, ty, ty))
+		tr := fc.typeResolver.Substitute(ty)
+
+		fmt.Printf(">>>[1] ty: (%[1]T): %[1]v\n", ty) // TODO(grantnelson-wf): remove
+		fmt.Printf(">>>[1] tr: (%[1]T): %[1]v\n", tr)
+		fmt.Printf(">>>[1] funcRef: %q\n", fc.funcRef)
+		fmt.Printf(">>>[1]-----------------\n")
+		fmt.Printf("%s\n", fc.typeResolver.String())
+		fmt.Printf(">>>[1]-----------------\n")
+
+		if tr != ty {
+			return fc.initArgs(tr)
+		}
+		err := bailout(fmt.Errorf(`"%v" has unexpected generic type parameter %T`, ty, ty))
 		panic(err)
 	default:
 		err := bailout(fmt.Errorf("%v has unexpected type %T", ty, ty))
diff --git a/internal/govendor/subst/export.go b/internal/govendor/subst/export.go
diff --git a/internal/govendor/subst/subst.go b/internal/govendor/subst/subst.go
