compiler: disambiguate function-local named types

Author: jakebailey

compiler/compiler.go

@@ -92,20 +92,22 @@ type compilerContext struct {
 	pkg              *types.Package
 	packageDir       string // directory for this package
 	runtimePkg       *types.Package
+	localTypeNames   map[*types.TypeName]string
 }
 
 // newCompilerContext returns a new compiler context ready for use, most
 // importantly with a newly created LLVM context and module.
 func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *Config, dumpSSA bool) *compilerContext {
 	c := &compilerContext{
-		Config:        config,
-		DumpSSA:       dumpSSA,
-		difiles:       make(map[string]llvm.Metadata),
-		ditypes:       make(map[types.Type]llvm.Metadata),
-		machine:       machine,
-		targetData:    machine.CreateTargetData(),
-		functionInfos: map[*ssa.Function]functionInfo{},
-		astComments:   map[string]*ast.CommentGroup{},
+		Config:         config,
+		DumpSSA:        dumpSSA,
+		difiles:        make(map[string]llvm.Metadata),
+		ditypes:        make(map[types.Type]llvm.Metadata),
+		machine:        machine,
+		targetData:     machine.CreateTargetData(),
+		functionInfos:  map[*ssa.Function]functionInfo{},
+		astComments:    map[string]*ast.CommentGroup{},
+		localTypeNames: map[*types.TypeName]string{},
 	}
 
 	c.ctx = llvm.NewContext()
@@ -300,6 +302,11 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	// Convert AST to SSA.
 	ssaPkg.Build()
 
+	// Assign names to function-local named types before compiling the
+	// package, so that types declared in different functions (or in
+	// different instantiations of a generic function) do not collide.
+	c.scanLocalTypes(ssaPkg)
+
 	// Initialize debug information.
 	if c.Debug {
 		c.cu = c.dibuilder.CreateCompileUnit(llvm.DICompileUnit{

compiler/interface.go

@@ -580,13 +580,27 @@ var basicTypeNames = [...]string{
 // getTypeCodeName returns a name for this type that can be used in the
 // interface lowering pass to assign type codes as expected by the reflect
 // package. See getTypeCodeNum.
-func (c *compilerContext) getTypeCodeName(t types.Type) (string, bool) {
+//
+// isLocal is true when the type is declared inside a function body.
+// Such types need a per-declaration (or per instantiation) suffix
+// because their printed names are not unique; scanLocalTypes assigns
+// the suffix and stores the result in c.localTypeNames.
+func (c *compilerContext) getTypeCodeName(t types.Type) (name string, isLocal bool) {
 	switch t := types.Unalias(t).(type) {
 	case *types.Named:
-		if t.Obj().Parent() != t.Obj().Pkg().Scope() {
-			return "named:" + t.String() + "$local", true
+		tn := t.Obj()
+		if tn.Pkg() == nil || tn.Parent() == tn.Pkg().Scope() {
+			// Package-scope or builtin: the printed name is unique.
+			return "named:" + t.String(), false
+		}
+		// Function-local type. Both ordinary locals (Parent() != nil)
+		// and synthetic locals from generic instantiation
+		// (Parent() == nil) are pre-registered by scanLocalTypes.
+		n, ok := c.localTypeNames[tn]
+		if !ok {
+			panic("compiler: local type " + tn.Name() + " was not registered by scanLocalTypes")
 		}
-		return "named:" + t.String(), false
+		return "named:" + n, true
 	case *types.Array:
 		s, isLocal := c.getTypeCodeName(t.Elem())
 		return "array:" + strconv.FormatInt(t.Len(), 10) + ":" + s, isLocal
@@ -672,6 +686,274 @@ func (c *compilerContext) getTypeCodeName(t types.Type) (string, bool) {
 	}
 }
 
+// scanLocalTypes assigns names to every function-local named type in
+// the package and stores them in c.localTypeNames. Two flavors are
+// handled:
+//
+//  1. Synthetic TypeNames produced by generic instantiation
+//     (TypeName.Parent() == nil). Two instantiations of the same
+//     generic function (e.g. F[int] and F[string]) produce TypeNames
+//     with the same printed name and the same source position, so
+//     each one is named with the enclosing instance's RelString as
+//     prefix. RelString encodes the type arguments, matching Go's
+//     runtime behavior, where F[int].Inner and F[string].Inner are
+//     distinct types even when Inner does not mention the type
+//     parameter.
+//
+//  2. Ordinary function-local TypeNames (TypeName.Parent() != nil).
+//     Each one is named with its declaring function's RelString plus
+//     a per-function counter assigned in source order. This mirrors
+//     the ·N suffix the standard Go compiler uses for such types and
+//     is robust against //line directives that would otherwise make a
+//     file:line:column suffix non-unique.
+//
+// Names depend only on intrinsic SSA properties (RelString and the
+// raw token.Pos used as a sort key), so any package compiling the
+// same function or instance produces the same identifier.
+func (c *compilerContext) scanLocalTypes(ssaPkg *ssa.Package) {
+	// Pass 1: locate every generic instance reachable from this
+	// package (including instances declared in imported packages and
+	// any function reached through an instance subtree). Synthetic
+	// TypeNames are produced by instantiation, so we need the call
+	// graph to find them all.
+	var instances []*ssa.Function
+	seenInstWalk := map[*ssa.Function]bool{}
+	var instWalk func(fn *ssa.Function, inInstance bool)
+	instWalk = func(fn *ssa.Function, inInstance bool) {
+		if fn == nil || seenInstWalk[fn] {
+			return
+		}
+		// fn belongs to an instance subtree if it is itself an
+		// instantiation or if we reached it from one.
+		//
+		// len(TypeArgs()) is used instead of fn.Origin() because
+		// Origin() may call Build() on fn's declaring package, which
+		// would defeat per-package compilation.
+		isInstanceRoot := len(fn.TypeArgs()) > 0
+		if !isInstanceRoot && !inInstance && fn.Pkg != ssaPkg {
+			return
+		}
+		if fn.Blocks == nil && fn.AnonFuncs == nil {
+			return
+		}
+		seenInstWalk[fn] = true
+		isInInstance := inInstance || isInstanceRoot
+		if isInInstance {
+			instances = append(instances, fn)
+		}
+		for _, anon := range fn.AnonFuncs {
+			instWalk(anon, isInInstance)
+		}
+		var ops [10]*ssa.Value
+		for _, b := range fn.Blocks {
+			for _, instr := range b.Instrs {
+				for _, op := range instr.Operands(ops[:0]) {
+					if op == nil || *op == nil {
+						continue
+					}
+					if callee, ok := (*op).(*ssa.Function); ok {
+						instWalk(callee, isInInstance)
+					}
+				}
+			}
+		}
+	}
+	for _, member := range ssaPkg.Members {
+		switch m := member.(type) {
+		case *ssa.Function:
+			instWalk(m, false)
+		case *ssa.Type:
+			mset := c.program.MethodSets.MethodSet(m.Type())
+			for i := 0; i < mset.Len(); i++ {
+				instWalk(c.program.MethodValue(mset.At(i)), false)
+			}
+			pmset := c.program.MethodSets.MethodSet(types.NewPointer(m.Type()))
+			for i := 0; i < pmset.Len(); i++ {
+				instWalk(c.program.MethodValue(pmset.At(i)), false)
+			}
+		}
+	}
+
+	// Pass 2: collect every non-instance function defined in this
+	// package together with its closures. Ordinary function-local
+	// TypeNames are scoped to their declaring function (and visible
+	// in nested closures only), so the declaring function is always
+	// somewhere in this lexical tree. Following callees here would
+	// be wrong: an instantiated function whose substituted signature
+	// mentions the local type would otherwise race with the actual
+	// declaring function for ownership.
+	var packageFuncs []*ssa.Function
+	var collect func(fn *ssa.Function)
+	collect = func(fn *ssa.Function) {
+		if fn == nil || fn.Pkg != ssaPkg {
+			return
+		}
+		if len(fn.TypeArgs()) > 0 {
+			// Generic instances are handled by pass 1 (their local
+			// types are synthetic).
+			return
+		}
+		if fn.Blocks == nil && fn.AnonFuncs == nil {
+			return
+		}
+		packageFuncs = append(packageFuncs, fn)
+		for _, anon := range fn.AnonFuncs {
+			collect(anon)
+		}
+	}
+	for _, member := range ssaPkg.Members {
+		switch m := member.(type) {
+		case *ssa.Function:
+			collect(m)
+		case *ssa.Type:
+			mset := c.program.MethodSets.MethodSet(m.Type())
+			for i := 0; i < mset.Len(); i++ {
+				collect(c.program.MethodValue(mset.At(i)))
+			}
+			pmset := c.program.MethodSets.MethodSet(types.NewPointer(m.Type()))
+			for i := 0; i < pmset.Len(); i++ {
+				collect(c.program.MethodValue(pmset.At(i)))
+			}
+		}
+	}
+
+	// Registration is first-writer-wins, so visit each list in a
+	// deterministic order. Pos() is a defensive tiebreaker.
+	sortFns := func(fns []*ssa.Function) {
+		sort.Slice(fns, func(i, j int) bool {
+			ri, rj := fns[i].RelString(nil), fns[j].RelString(nil)
+			if ri != rj {
+				return ri < rj
+			}
+			return fns[i].Pos() < fns[j].Pos()
+		})
+	}
+	sortFns(instances)
+	sortFns(packageFuncs)
+	for _, fn := range instances {
+		c.registerLocalTypes(fn, true)
+	}
+	for _, fn := range packageFuncs {
+		c.registerLocalTypes(fn, false)
+	}
+}
+
+// registerLocalTypes walks every type reachable from fn's body and
+// records each function-local TypeName whose Parent() matches the
+// synthetic flag (Parent() == nil for synthetic, != nil otherwise) in
+// c.localTypeNames. Each TypeName is named with fn.RelString as the
+// owning function plus a per-function counter assigned in source order.
+//
+// First-writer-wins: a TypeName already present in c.localTypeNames
+// is left alone. The slot is reserved with an empty string during
+// collection so later registerLocalTypes calls (within the same
+// scanLocalTypes invocation) skip it; the final name is filled in
+// after sorting, before scanLocalTypes returns and any
+// getTypeCodeName lookups happen.
+func (c *compilerContext) registerLocalTypes(fn *ssa.Function, synthetic bool) {
+	var found []*types.TypeName
+	seen := map[types.Type]bool{}
+	var visit func(t types.Type)
+	visit = func(t types.Type) {
+		if t == nil || seen[t] {
+			return
+		}
+		seen[t] = true
+		switch t := t.(type) {
+		case *types.Alias:
+			visit(types.Unalias(t))
+		case *types.Named:
+			tn := t.Obj()
+			if tn.Pkg() != nil && (tn.Parent() == nil) == synthetic {
+				if _, ok := c.localTypeNames[tn]; !ok {
+					c.localTypeNames[tn] = ""
+					found = append(found, tn)
+				}
+			}
+			targs := t.TypeArgs()
+			for i := 0; i < targs.Len(); i++ {
+				visit(targs.At(i))
+			}
+			visit(t.Underlying())
+		case *types.Pointer:
+			visit(t.Elem())
+		case *types.Slice:
+			visit(t.Elem())
+		case *types.Array:
+			visit(t.Elem())
+		case *types.Chan:
+			visit(t.Elem())
+		case *types.Map:
+			visit(t.Key())
+			visit(t.Elem())
+		case *types.Struct:
+			for i := 0; i < t.NumFields(); i++ {
+				visit(t.Field(i).Type())
+			}
+		case *types.Signature:
+			if p := t.Params(); p != nil {
+				for i := 0; i < p.Len(); i++ {
+					visit(p.At(i).Type())
+				}
+			}
+			if r := t.Results(); r != nil {
+				for i := 0; i < r.Len(); i++ {
+					visit(r.At(i).Type())
+				}
+			}
+		case *types.Tuple:
+			for i := 0; i < t.Len(); i++ {
+				visit(t.At(i).Type())
+			}
+		case *types.Interface:
+			// A local type can be reachable only through a local
+			// interface's method signature, so descend into them.
+			// getTypeCodeName encodes those signatures into the
+			// interface's identifier, and the seen map breaks
+			// cycles formed by methods that mention the interface
+			// itself.
+			for i := 0; i < t.NumMethods(); i++ {
+				visit(t.Method(i).Type())
+			}
+		}
+	}
+	for _, p := range fn.Params {
+		visit(p.Type())
+	}
+	for _, fv := range fn.FreeVars {
+		visit(fv.Type())
+	}
+	for _, l := range fn.Locals {
+		visit(l.Type())
+	}
+	var ops [10]*ssa.Value
+	for _, b := range fn.Blocks {
+		for _, instr := range b.Instrs {
+			if v, ok := instr.(ssa.Value); ok {
+				visit(v.Type())
+			}
+			for _, op := range instr.Operands(ops[:0]) {
+				if op != nil && *op != nil {
+					visit((*op).Type())
+				}
+			}
+		}
+	}
+	if len(found) == 0 {
+		return
+	}
+	// Sort by raw token.Pos: this gives a total order on declarations
+	// that is stable across builds and unaffected by //line directives
+	// (which only adjust the human-facing position from Fset.Position).
+	sort.Slice(found, func(i, j int) bool {
+		return found[i].Pos() < found[j].Pos()
+	})
+	enclosing := fn.RelString(nil)
+	for i, tn := range found {
+		c.localTypeNames[tn] = enclosing + "." + tn.Name() + "$" + strconv.Itoa(i+1)
+	}
+}
+
 // getTypeMethodSet returns a reference (GEP) to a global method set. This
 // method set should be unreferenced after the interface lowering pass.
 func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {