compiler: disambiguate generic instances with function-local type aliases

x/tools go/ssa names instantiations using the type argument's String().
Function-local aliases like `type F = float64` therefore collide when two
callers use distinct aliases named F (Go 1.27's internal/strconv.ftoa32
and ftoa64 do exactly this). Extend localTypeArgsSuffix to detect local
aliases and include their declaration position, so the float32 and
float64 instantiations get distinct LLVM symbols.

Fixes wrong float formatting in strconv/math on Go 1.27, and adds a
regression test to testdata/localtypes.go.

Signed-off-by: deadprogram <ron@hybridgroup.com>

compiler/symbol.go

@@ -8,6 +8,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+	"path/filepath"
 	"slices"
 	"strconv"
 	"strings"
@@ -365,6 +366,22 @@ func (c *compilerContext) localTypeArgsSuffix(f *ssa.Function) string {
 		if isLocal {
 			hasLocal = true
 		}
+		// A function-local type alias (e.g. `type F = float64` inside a
+		// function body) is invisible to getTypeCodeName because it calls
+		// types.Unalias first. Two callers that use distinct aliases with
+		// the same name (e.g. Go 1.27's internal/strconv.ftoa32 and ftoa64
+		// both declare a local `type F = ...`) then produce identical
+		// RelStrings for their shortFloat[F] instantiations and collide on
+		// mod.NamedFunction. Treat these aliases as local so the suffix
+		// disambiguates them.
+		if alias, ok := ta.(*types.Alias); ok {
+			if obj := alias.Obj(); obj.Pkg() != nil && obj.Parent() != obj.Pkg().Scope() {
+				hasLocal = true
+				pos := c.program.Fset.PositionFor(obj.Pos(), false)
+				parts[i] = fmt.Sprintf("%s$alias:%s:%d:%d", name, filepath.Base(pos.Filename), pos.Line, pos.Column)
+				continue
+			}
+		}
 		parts[i] = name
 	}
 	if !hasLocal {