Working on package analysis

Author: grantnelson-wf

build/build.go

@@ -27,11 +27,9 @@ import (
 	"github.com/fsnotify/fsnotify"
 	"github.com/gopherjs/gopherjs/compiler"
 	"github.com/gopherjs/gopherjs/compiler/astutil"
-	"github.com/gopherjs/gopherjs/compiler/internal/typeparams"
 	"github.com/gopherjs/gopherjs/compiler/jsFile"
 	"github.com/gopherjs/gopherjs/compiler/sources"
 	"github.com/gopherjs/gopherjs/internal/errorList"
-	"github.com/gopherjs/gopherjs/internal/experiments"
 	"github.com/gopherjs/gopherjs/internal/testmain"
 	log "github.com/sirupsen/logrus"
 
@@ -938,10 +936,11 @@ func (s *Session) BuildProject(pkg *PackageData) (*compiler.Archive, error) {
 		return nil, err
 	}
 
-	// TODO(grantnelson-wf): Handle newRootCtx changes
+	// Propagate the analysis information to all packages.
+	compiler.PropagateAnalysis(s.sources)
 
 	// Compile the project into Archives containing the generated JS.
-	return s.compilePackages(srcs)
+	return s.compilePackages(srcs, tContext)
 }
 
 func (s *Session) loadTestPackage(pkg *PackageData) (*sources.Sources, error) {
@@ -1109,43 +1108,32 @@ func (s *Session) loadPackages(pkg *PackageData) (*sources.Sources, error) {
 	return srcs, nil
 }
 
-type importContext struct {
-	s        *Session
-	dir      string
-	tContext *types.Context
-}
-
-func (ic *importContext) Import(path string) (*types.Package, error) {
-
-}
-
 func (s *Session) prepareSources(srcs *sources.Sources, tContext *types.Context) error {
-	ic := &importContext{
-		s:        s,
-		dir:      srcs.Dir,
-		tContext: tContext,
-	}
-
-	if err := srcs.TypeCheck(ic, sizes32, tContext); err != nil {
-		return err
-	}
+	importer := func(path string) (*sources.Sources, error) {
+		importPath, err := s.getImportPath(path, srcs.Dir)
+		if err != nil {
+			return nil, err
+		}
 
-	if genErr := typeparams.RequiresGenericsSupport(srcs.TypeInfo); genErr != nil && !experiments.Env.Generics {
-		return fmt.Errorf("package %s requires generics support (https://github.com/gopherjs/gopherjs/issues/1013): %w", srcs.ImportPath, genErr)
-	}
+		if srcs, ok := s.sources[importPath]; ok {
+			if srcs.Package == nil {
+				err = s.prepareSources(srcs, tContext)
+				if err != nil {
+					return nil, err
+				}
+			}
+			return srcs, nil
+		}
 
-	// Extract all go:linkname compiler directives from the package source.
-	if err := srcs.ParseGoLinknames(); err != nil {
-		return err
+		return nil, fmt.Errorf(`sources for %q not found`, importPath)
 	}
 
-	srcs.Simplify()
-	return nil
+	return compiler.PrepareSources(srcs, importer, tContext)
 }
 
-func (s *Session) compilePackages(rootSrcs *sources.Sources) (*compiler.Archive, error) {
+func (s *Session) compilePackages(rootSrcs *sources.Sources, tContext *types.Context) (*compiler.Archive, error) {
 	for _, srcs := range s.sources {
-		archive, err := compiler.Compile(*srcs, s.options.Minify)
+		archive, err := compiler.Compile(*srcs, tContext, s.options.Minify)
 		if err != nil {
 			return nil, err
 		}
@@ -1199,12 +1187,7 @@ func (s *Session) ImportResolverFor(srcDir string) func(string) (*compiler.Archi
 			return archive, nil
 		}
 
-		// The archive hasn't been compiled yet so compile it with the sources.
-		if srcs, ok := s.sources[importPath]; ok {
-			return s.compilePackages(srcs)
-		}
-
-		return nil, fmt.Errorf(`sources for %q not found`, importPath)
+		return nil, fmt.Errorf(`archive for %q not found`, importPath)
 	}
 }
 

compiler/internal/analysis/info.go

@@ -58,10 +58,12 @@ type Info struct {
 	funcLitInfos  map[*ast.FuncLit][]*FuncInfo
 	InitFuncInfo  *FuncInfo // Context for package variable initialization.
 
-	isImportedBlocking func(typeparams.Instance) bool // For functions from other packages.
-	allInfos           []*FuncInfo
+	infoImporter InfoImporter // For functions from other packages.
+	allInfos     []*FuncInfo
 }
 
+type InfoImporter func(path string) (*Info, error)
+
 func (info *Info) newFuncInfo(n ast.Node, obj types.Object, typeArgs typesutil.TypeList, resolver *typeparams.Resolver) *FuncInfo {
 	funcInfo := &FuncInfo{
 		pkgInfo:            info,
@@ -132,11 +134,16 @@ func (info *Info) newFuncInfoInstances(fd *ast.FuncDecl) []*FuncInfo {
 }
 
 // IsBlocking returns true if the function may contain blocking calls or operations.
-// If inst is from a different package, this will use the isImportedBlocking
+// If inst is from a different package, this will use the getImportInfo function
 // to lookup the information from the other package.
 func (info *Info) IsBlocking(inst typeparams.Instance) bool {
 	if inst.Object.Pkg() != info.Pkg {
-		return info.isImportedBlocking(inst)
+		path := inst.Object.Pkg().Path()
+		otherInfo, err := info.infoImporter(path)
+		if err != nil {
+			panic(fmt.Errorf(`failed to get info for package %q: %v`, path, err))
+		}
+		return otherInfo.IsBlocking(inst)
 	}
 	if funInfo := info.FuncInfo(inst); funInfo != nil {
 		return funInfo.IsBlocking()
@@ -174,16 +181,21 @@ func (info *Info) VarsWithInitializers() map[*types.Var]bool {
 	return result
 }
 
-func AnalyzePkg(files []*ast.File, fileSet *token.FileSet, typesInfo *types.Info, typeCtx *types.Context, typesPkg *types.Package, instanceSets *typeparams.PackageInstanceSets, isBlocking func(typeparams.Instance) bool) *Info {
+// AnalyzePkg analyzes the given package for blocking calls, defers, etc.
+//
+// Note that at the end of this call the analysis information
+// has NOT been propagated across packages yet. Once all the packages
+// have been analyzed, call PropagateAnalysis to propagate the information.
+func AnalyzePkg(files []*ast.File, fileSet *token.FileSet, typesInfo *types.Info, typeCtx *types.Context, typesPkg *types.Package, instanceSets *typeparams.PackageInstanceSets, infoImporter InfoImporter) *Info {
 	info := &Info{
-		Info:               typesInfo,
-		Pkg:                typesPkg,
-		typeCtx:            typeCtx,
-		instanceSets:       instanceSets,
-		HasPointer:         make(map[*types.Var]bool),
-		isImportedBlocking: isBlocking,
-		funcInstInfos:      new(typeparams.InstanceMap[*FuncInfo]),
-		funcLitInfos:       make(map[*ast.FuncLit][]*FuncInfo),
+		Info:          typesInfo,
+		Pkg:           typesPkg,
+		typeCtx:       typeCtx,
+		instanceSets:  instanceSets,
+		HasPointer:    make(map[*types.Var]bool),
+		infoImporter:  infoImporter,
+		funcInstInfos: new(typeparams.InstanceMap[*FuncInfo]),
+		funcLitInfos:  make(map[*ast.FuncLit][]*FuncInfo),
 	}
 	info.InitFuncInfo = info.newFuncInfo(nil, nil, nil, nil)
 
@@ -193,13 +205,25 @@ func AnalyzePkg(files []*ast.File, fileSet *token.FileSet, typesInfo *types.Info
 		ast.Walk(info.InitFuncInfo, file)
 	}
 
+	return info
+}
+
+// PropagateAnalysis will propagate analysis information across package
+// boundaries to finish the analysis of a whole project.
+func PropagateAnalysis(allInfo []*Info) {
 	done := false
 	for !done {
-		done = info.propagateFunctionBlocking()
+		done = true
+		for _, info := range allInfo {
+			if !info.propagateFunctionBlocking() {
+				done = false
+			}
+		}
 	}
 
-	info.propagateControlStatementBlocking()
-	return info
+	for _, info := range allInfo {
+		info.propagateControlStatementBlocking()
+	}
 }
 
 // propagateFunctionBlocking propagates information about blocking calls

compiler/internal/analysis/info_test.go

@@ -1,6 +1,7 @@
 package analysis
 
 import (
+	"fmt"
 	"go/ast"
 	"go/types"
 	"sort"
@@ -1639,11 +1640,10 @@ func newBlockingTest(t *testing.T, src string) *blockingTest {
 	testInfo, testPkg := f.Check(`pkg/test`, file)
 	tc.Scan(testPkg, file)
 
-	isImportBlocking := func(i typeparams.Instance) bool {
-		t.Fatalf(`isImportBlocking should not be called in this test, called with %v`, i)
-		return true
+	getImportInfo := func(path string) (*Info, error) {
+		return nil, fmt.Errorf(`getImportInfo should not be called in this test, called with %v`, path)
 	}
-	pkgInfo := AnalyzePkg([]*ast.File{file}, f.FileSet, testInfo, types.NewContext(), testPkg, tc.Instances, isImportBlocking)
+	pkgInfo := AnalyzePkg([]*ast.File{file}, f.FileSet, testInfo, types.NewContext(), testPkg, tc.Instances, getImportInfo)
 
 	return &blockingTest{
 		f:       f,
@@ -1660,13 +1660,12 @@ func newBlockingTestWithOtherPackage(t *testing.T, testSrc string, otherSrc stri
 		Instances: &typeparams.PackageInstanceSets{},
 	}
 
-	pkgInfo := map[*types.Package]*Info{}
-	isImportBlocking := func(i typeparams.Instance) bool {
-		if info, ok := pkgInfo[i.Object.Pkg()]; ok {
-			return info.IsBlocking(i)
+	pkgInfo := map[string]*Info{}
+	getImportInfo := func(path string) (*Info, error) {
+		if info, ok := pkgInfo[path]; ok {
+			return info, nil
 		}
-		t.Fatalf(`unexpected package in isImportBlocking for %v`, i)
-		return true
+		return nil, fmt.Errorf(`unexpected package in getImportInfo for %v`, path)
 	}
 
 	otherFile := f.Parse(`other.go`, otherSrc)
@@ -1677,11 +1676,11 @@ func newBlockingTestWithOtherPackage(t *testing.T, testSrc string, otherSrc stri
 	_, testPkg := f.Check(`pkg/test`, testFile)
 	tc.Scan(testPkg, testFile)
 
-	otherPkgInfo := AnalyzePkg([]*ast.File{otherFile}, f.FileSet, f.Info, types.NewContext(), otherPkg, tc.Instances, isImportBlocking)
-	pkgInfo[otherPkg] = otherPkgInfo
+	otherPkgInfo := AnalyzePkg([]*ast.File{otherFile}, f.FileSet, f.Info, types.NewContext(), otherPkg, tc.Instances, getImportInfo)
+	pkgInfo[otherPkg.Path()] = otherPkgInfo
 
-	testPkgInfo := AnalyzePkg([]*ast.File{testFile}, f.FileSet, f.Info, types.NewContext(), testPkg, tc.Instances, isImportBlocking)
-	pkgInfo[testPkg] = testPkgInfo
+	testPkgInfo := AnalyzePkg([]*ast.File{testFile}, f.FileSet, f.Info, types.NewContext(), testPkg, tc.Instances, getImportInfo)
+	pkgInfo[testPkg.Path()] = testPkgInfo
 
 	return &blockingTest{
 		f:       f,