go/ssa: propagate goversions in ssa

Propagate goversions on functions and initializers.

Updates golang/go#63374

Change-Id: I67b25b65fd83888fa27818aee3570b8bf4c09508
Reviewed-on: https://go-review.googlesource.com/c/tools/+/533239
TryBot-Result: Gopher Robot <[email protected]>
Run-TryBot: Tim King <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: timothy-king

go/ssa/builder.go

@@ -647,7 +647,8 @@ func (b *builder) expr0(fn *Function, e ast.Expr, tv types.TypeAndValue) Value {
 			typeparams:     fn.typeparams, // share the parent's type parameters.
 			typeargs:       fn.typeargs,   // share the parent's type arguments.
 			info:           fn.info,
-			subst:          fn.subst, // share the parent's type substitutions.
+			subst:          fn.subst,     // share the parent's type substitutions.
+			goversion:      fn.goversion, // share the parent's goversion
 		}
 		fn.AnonFuncs = append(fn.AnonFuncs, fn2)
 		b.created.Add(fn2)
@@ -2516,11 +2517,18 @@ func (p *Package) build() {
 	if len(p.info.InitOrder) > 0 && len(p.files) == 0 {
 		panic("no source files provided for package. cannot initialize globals")
 	}
+
 	for _, varinit := range p.info.InitOrder {
 		if init.Prog.mode&LogSource != 0 {
 			fmt.Fprintf(os.Stderr, "build global initializer %v @ %s\n",
 				varinit.Lhs, p.Prog.Fset.Position(varinit.Rhs.Pos()))
 		}
+		// Initializers for global vars are evaluated in dependency
+		// order, but may come from arbitrary files of the package
+		// with different versions, so we transiently update
+		// init.goversion for each one. (Since init is a synthetic
+		// function it has no syntax of its own that needs a version.)
+		init.goversion = p.initVersion[varinit.Rhs]
 		if len(varinit.Lhs) == 1 {
 			// 1:1 initialization: var x, y = a(), b()
 			var lval lvalue
@@ -2541,6 +2549,7 @@ func (p *Package) build() {
 			}
 		}
 	}
+	init.goversion = "" // The rest of the init function is synthetic. No syntax => no goversion.
 
 	// Call all of the declared init() functions in source order.
 	for _, file := range p.files {
@@ -2585,8 +2594,11 @@ func (p *Package) build() {
 		b.needsRuntimeTypes() // Add all of the runtime type information. May CREATE Functions.
 	}
 
-	p.info = nil    // We no longer need ASTs or go/types deductions.
-	p.created = nil // We no longer need created functions.
+	// We no longer need transient information: ASTs or go/types deductions.
+	p.info = nil
+	p.created = nil
+	p.files = nil
+	p.initVersion = nil
 
 	if p.Prog.mode&SanityCheckFunctions != 0 {
 		sanityCheckPackage(p)

go/ssa/builder_go122_test.go

@@ -0,0 +1,88 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.22
+// +build go1.22
+
+package ssa_test
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"testing"
+
+	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/ssa/ssautil"
+)
+
+func TestMultipleGoversions(t *testing.T) {
+	var contents = map[string]string{
+		"post.go": `
+	//go:build go1.22
+	package p
+
+	var distinct = func(l []int) []*int {
+		var r []*int
+		for i := range l {
+			r = append(r, &i)
+		}
+		return r
+	}(l)
+	`,
+		"pre.go": `
+	package p
+
+	var l = []int{0, 0, 0}
+
+	var same = func(l []int) []*int {
+		var r []*int
+		for i := range l {
+			r = append(r, &i)
+		}
+		return r
+	}(l)
+	`,
+	}
+
+	fset := token.NewFileSet()
+	var files []*ast.File
+	for _, fname := range []string{"post.go", "pre.go"} {
+		file, err := parser.ParseFile(fset, fname, contents[fname], 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		files = append(files, file)
+	}
+
+	pkg := types.NewPackage("p", "")
+	conf := &types.Config{Importer: nil, GoVersion: "go1.21"}
+	p, _, err := ssautil.BuildPackage(conf, fset, pkg, files, ssa.SanityCheckFunctions)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+
+	fns := ssautil.AllFunctions(p.Prog)
+	names := make(map[string]*ssa.Function)
+	for fn := range fns {
+		names[fn.String()] = fn
+	}
+	for _, item := range []struct{ name, wantSyn, wantPos string }{
+		{"p.init", "package initializer", "-"},
+		{"p.init$1", "", "post.go:5:17"},
+		{"p.init$2", "", "pre.go:6:13"},
+	} {
+		fn := names[item.name]
+		if fn == nil {
+			t.Fatalf("Could not find function named %q in package %s", item.name, p)
+		}
+		if fn.Synthetic != item.wantSyn {
+			t.Errorf("Function %q.Syntethic=%q. expected %q", fn, fn.Synthetic, item.wantSyn)
+		}
+		if got := fset.Position(fn.Pos()).String(); got != item.wantPos {
+			t.Errorf("Function %q.Pos()=%q. expected %q", fn, got, item.wantPos)
+		}
+	}
+}

go/ssa/create.go

@@ -47,9 +47,10 @@ func NewProgram(fset *token.FileSet, mode BuilderMode) *Program {
 // typechecker object obj.
 //
 // For objects from Go source code, syntax is the associated syntax
-// tree (for funcs and vars only); it will be used during the build
+// tree (for funcs and vars only) and goversion defines the
+// appropriate interpretation; they will be used during the build
 // phase.
-func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node) {
+func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node, goversion string) {
 	name := obj.Name()
 	switch obj := obj.(type) {
 	case *types.Builtin:
@@ -108,6 +109,7 @@ func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node) {
 			Prog:       pkg.Prog,
 			typeparams: tparams,
 			info:       pkg.info,
+			goversion:  goversion,
 		}
 		pkg.created.Add(fn)
 		if syntax == nil {
@@ -130,24 +132,27 @@ func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node) {
 // membersFromDecl populates package pkg with members for each
 // typechecker object (var, func, const or type) associated with the
 // specified decl.
-func membersFromDecl(pkg *Package, decl ast.Decl) {
+func membersFromDecl(pkg *Package, decl ast.Decl, goversion string) {
 	switch decl := decl.(type) {
 	case *ast.GenDecl: // import, const, type or var
 		switch decl.Tok {
 		case token.CONST:
 			for _, spec := range decl.Specs {
 				for _, id := range spec.(*ast.ValueSpec).Names {
 					if !isBlankIdent(id) {
-						memberFromObject(pkg, pkg.info.Defs[id], nil)
+						memberFromObject(pkg, pkg.info.Defs[id], nil, "")
 					}
 				}
 			}
 
 		case token.VAR:
 			for _, spec := range decl.Specs {
+				for _, rhs := range spec.(*ast.ValueSpec).Values {
+					pkg.initVersion[rhs] = goversion
+				}
 				for _, id := range spec.(*ast.ValueSpec).Names {
 					if !isBlankIdent(id) {
-						memberFromObject(pkg, pkg.info.Defs[id], spec)
+						memberFromObject(pkg, pkg.info.Defs[id], spec, goversion)
 					}
 				}
 			}
@@ -156,15 +161,15 @@ func membersFromDecl(pkg *Package, decl ast.Decl) {
 			for _, spec := range decl.Specs {
 				id := spec.(*ast.TypeSpec).Name
 				if !isBlankIdent(id) {
-					memberFromObject(pkg, pkg.info.Defs[id], nil)
+					memberFromObject(pkg, pkg.info.Defs[id], nil, "")
 				}
 			}
 		}
 
 	case *ast.FuncDecl:
 		id := decl.Name
 		if !isBlankIdent(id) {
-			memberFromObject(pkg, pkg.info.Defs[id], decl)
+			memberFromObject(pkg, pkg.info.Defs[id], decl, goversion)
 		}
 	}
 }
@@ -197,8 +202,10 @@ func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *
 		Members: make(map[string]Member),
 		objects: make(map[types.Object]Member),
 		Pkg:     pkg,
-		info:    info,  // transient (CREATE and BUILD phases)
-		files:   files, // transient (CREATE and BUILD phases)
+		// transient values (CREATE and BUILD phases)
+		info:        info,
+		files:       files,
+		initVersion: make(map[ast.Expr]string),
 	}
 
 	// Add init() function.
@@ -209,6 +216,7 @@ func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *
 		Pkg:       p,
 		Prog:      prog,
 		info:      p.info,
+		goversion: "", // See Package.build() for details.
 	}
 	p.Members[p.init.name] = p.init
 	p.created.Add(p.init)
@@ -218,8 +226,9 @@ func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *
 	if len(files) > 0 {
 		// Go source package.
 		for _, file := range files {
+			goversion := goversionOf(p, file)
 			for _, decl := range file.Decls {
-				membersFromDecl(p, decl)
+				membersFromDecl(p, decl, goversion)
 			}
 		}
 	} else {
@@ -229,11 +238,11 @@ func (prog *Program) CreatePackage(pkg *types.Package, files []*ast.File, info *
 		scope := p.Pkg.Scope()
 		for _, name := range scope.Names() {
 			obj := scope.Lookup(name)
-			memberFromObject(p, obj, nil)
+			memberFromObject(p, obj, nil, "")
 			if obj, ok := obj.(*types.TypeName); ok {
 				if named, ok := obj.Type().(*types.Named); ok {
 					for i, n := 0, named.NumMethods(); i < n; i++ {
-						memberFromObject(p, named.Method(i), nil)
+						memberFromObject(p, named.Method(i), nil, "")
 					}
 				}
 			}

go/ssa/func.go

@@ -324,6 +324,7 @@ func (f *Function) finishBody() {
 	f.namedResults = nil // (used by lifting)
 	f.info = nil
 	f.subst = nil
+	f.goversion = ""
 
 	numberRegisters(f) // uses f.namedRegisters
 }

go/ssa/instantiate.go

@@ -32,8 +32,8 @@ type instanceSet struct {
 	fn        *Function               // fn.typeparams.Len() > 0 and len(fn.typeargs) == 0.
 	instances map[*typeList]*Function // canonical type arguments to an instance.
 	syntax    *ast.FuncDecl           // fn.syntax copy for instantiating after fn is done. nil on synthetic packages.
-	info      *types.Info             // fn.pkg.info copy for building after fn is done.. nil on synthetic packages.
-
+	info      *types.Info             // fn.pkg.info copy for building after fn is done. nil on synthetic packages.
+	goversion string                  // goversion to build syntax with.
 	// TODO(taking): Consider ways to allow for clearing syntax and info when done building.
 	// May require a public API change as MethodValue can request these be built after prog.Build() is done.
 }
@@ -66,9 +66,10 @@ func (prog *Program) createInstanceSet(fn *Function) {
 
 	if _, ok := prog.instances[fn]; !ok {
 		prog.instances[fn] = &instanceSet{
-			fn:     fn,
-			syntax: syntax,
-			info:   fn.info,
+			fn:        fn,
+			syntax:    syntax,
+			info:      fn.info,
+			goversion: fn.goversion,
 		}
 	}
 }
@@ -169,8 +170,8 @@ func (insts *instanceSet) lookupOrCreate(targs []types.Type, parameterized *tpWa
 		typeargs:       targs,
 		info:           insts.info, // on synthetic packages info is nil.
 		subst:          subst,
+		goversion:      insts.goversion,
 	}
-
 	cr.Add(instance)
 	insts.instances[key] = instance
 	return instance

go/ssa/source.go

@@ -11,6 +11,7 @@ package ssa
 // the originating syntax, as specified.
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 	"go/types"
@@ -131,6 +132,31 @@ func findNamedFunc(pkg *Package, pos token.Pos) *Function {
 	return nil
 }
 
+// goversionOf returns the goversion of a node in the package
+// where the node is either a function declaration or the initial
+// value of a package level variable declaration.
+func goversionOf(p *Package, file *ast.File) string {
+	if p.info == nil {
+		return ""
+	}
+
+	// TODO(taking): Update to the following when internal/versions available:
+	//	return versions.Lang(versions.FileVersions(p.info, file))
+	return fileVersions(file)
+}
+
+// TODO(taking): Remove when internal/versions is available.
+var fileVersions = func(file *ast.File) string { return "" }
+
+// parses a goXX.YY version or returns a negative version on an error.
+// TODO(taking): Switch to a permanent solution when internal/versions is submitted.
+func parseGoVersion(x string) (major, minor int) {
+	if _, err := fmt.Sscanf(x, "go%d.%d", &major, &minor); err != nil || major < 0 || minor < 0 {
+		return -1, -1
+	}
+	return
+}
+
 // ValueForExpr returns the SSA Value that corresponds to non-constant
 // expression e.
 //

go/ssa/ssa.go

@@ -57,11 +57,12 @@ type Package struct {
 
 	// The following fields are set transiently, then cleared
 	// after building.
-	buildOnce sync.Once   // ensures package building occurs once
-	ninit     int32       // number of init functions
-	info      *types.Info // package type information
-	files     []*ast.File // package ASTs
-	created   creator     // members created as a result of building this package (includes declared functions, wrappers)
+	buildOnce   sync.Once           // ensures package building occurs once
+	ninit       int32               // number of init functions
+	info        *types.Info         // package type information
+	files       []*ast.File         // package ASTs
+	created     creator             // members created as a result of building this package (includes declared functions, wrappers)
+	initVersion map[ast.Expr]string // goversion to use for each global var init expr
 }
 
 // A Member is a member of a Go package, implemented by *NamedConst,
@@ -338,6 +339,7 @@ type Function struct {
 	lblocks      map[types.Object]*lblock // labelled blocks
 	info         *types.Info              // *types.Info to build from. nil for wrappers.
 	subst        *subster                 // non-nil => expand generic body using this type substitution of ground types
+	goversion    string                   // Go version of syntax (NB: init is special)
 }
 
 // BasicBlock represents an SSA basic block.

go/ssa/ssautil/load.go

@@ -147,6 +147,7 @@ func BuildPackage(tc *types.Config, fset *token.FileSet, pkg *types.Package, fil
 		Selections: make(map[*ast.SelectorExpr]*types.Selection),
 	}
 	typeparams.InitInstanceInfo(info)
+	// versions.InitFileVersions(info) // TODO(taking): Enable when internal/versions is available.
 	if err := types.NewChecker(tc, fset, pkg, info).Files(files); err != nil {
 		return nil, nil, err
 	}

go/ssa/versions_go122.go

@@ -0,0 +1,21 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.22
+// +build go1.22
+
+package ssa
+
+import (
+	"go/ast"
+)
+
+func init() {
+	fileVersions = func(file *ast.File) string {
+		if maj, min := parseGoVersion(file.GoVersion); maj >= 0 && min >= 0 {
+			return file.GoVersion
+		}
+		return ""
+	}
+}