merged test generation into build

Author: grantnelson-wf

build/build.go

@@ -27,6 +27,7 @@ import (
 	"github.com/fsnotify/fsnotify"
 	"github.com/gopherjs/gopherjs/compiler"
 	"github.com/gopherjs/gopherjs/compiler/astutil"
+	"github.com/gopherjs/gopherjs/internal/testmain"
 	log "github.com/sirupsen/logrus"
 
 	"github.com/neelance/sourcemap"
@@ -686,14 +687,6 @@ func (p PackageData) FileModTime() time.Time {
 	return newest
 }
 
-// InternalBuildContext returns the build context that produced the package.
-//
-// WARNING: This function is a part of internal API and will be removed in
-// future.
-func (p *PackageData) InternalBuildContext() *build.Context {
-	return p.bctx
-}
-
 // TestPackage returns a variant of the package with "internal" tests.
 func (p *PackageData) TestPackage() *PackageData {
 	return &PackageData{
@@ -913,11 +906,7 @@ func (s *Session) BuildFiles(filenames []string, pkgObj string, cwd string) erro
 		})
 	}
 
-	parsed, err := s.BuildPackage(pkg)
-	if err != nil {
-		return err
-	}
-	archive, err := s.CompilePackage(parsed)
+	archive, err := s.BuildProject(pkg)
 	if err != nil {
 		return err
 	}
@@ -927,7 +916,73 @@ func (s *Session) BuildFiles(filenames []string, pkgObj string, cwd string) erro
 	return s.WriteCommandPackage(archive, pkgObj)
 }
 
-// buildImportPathWithSrcDir builds the package specified by the import path.
+func (s *Session) BuildProject(pkg *PackageData) (*compiler.Archive, error) {
+	var parsed *ParsedPackage
+	var err error
+	if pkg.IsTest {
+		parsed, err = s.buildTestProject(pkg)
+	} else {
+		parsed, err = s.buildNonTestProject(pkg)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO(grantnelson-wf): At this point we should have all the parsed packages we need to
+	// compile the whole project. We can perform analysis on the whole project
+	// at this point to get the propagate flatten, blocking, etc. information
+	// and check types to get the type info with all the instances for all
+	// generics in the whole project.
+
+	return s.compilePackages(parsed)
+}
+
+func (s *Session) buildTestProject(pkg *PackageData) (*ParsedPackage, error) {
+	tpkg := pkg.TestPackage()
+	tpkg.Imports = append(tpkg.Imports,
+		"github.com/gopherjs/gopherjs/js",
+		"github.com/gopherjs/gopherjs/nosync",
+		"testing/internal/testdeps",
+		"runtime",
+	)
+	_, err := s.buildPackages(tpkg)
+	if err != nil {
+		return nil, err
+	}
+	_, err = s.buildPackages(pkg.XTestPackage())
+	if err != nil {
+		return nil, err
+	}
+
+	fset := token.NewFileSet()
+	tests := testmain.TestMain{Package: pkg.Package, Context: pkg.bctx}
+	tests.Scan(fset)
+	mainPkg, mainFile, err := tests.Synthesize(fset)
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate testmain package for %s: %w", pkg.ImportPath, err)
+	}
+
+	parsed := &ParsedPackage{
+		ImportPath: mainPkg.ImportPath,
+		Dir:        mainPkg.Dir,
+		GoFiles:    []*ast.File{mainFile},
+		FileSet:    fset,
+	}
+
+	return parsed, nil
+}
+
+func (s *Session) buildNonTestProject(pkg *PackageData) (*ParsedPackage, error) {
+	// Add some packages required by GopherJS as imports.
+	pkg.Imports = append(pkg.Imports,
+		"github.com/gopherjs/gopherjs/js",
+		"github.com/gopherjs/gopherjs/nosync",
+		"runtime",
+	)
+	return s.buildPackages(pkg)
+}
+
+// buildImportPathWithSrcDir builds the parsed package specified by the import path.
 //
 // Relative import paths are interpreted relative to the passed srcDir. If
 // srcDir is empty, current working directory is assumed.
@@ -940,7 +995,7 @@ func (s *Session) buildImportPathWithSrcDir(path string, srcDir string) (*Packag
 		return nil, nil, err
 	}
 
-	parsed, err := s.recursivelyBuildPackages(pkg)
+	parsed, err := s.buildPackages(pkg)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -974,23 +1029,7 @@ var getExeModTime = func() func() time.Time {
 	}
 }()
 
-func (s *Session) BuildPackage(pkg *PackageData) (*ParsedPackage, error) {
-	// If testing add in the required test imports into the package.
-	if pkg.IsTest {
-		pkg = pkg.TestPackage()
-		// Add some packages required by GopherJS for tests as imports.
-		pkg.Imports = append(pkg.Imports,
-			"testing/internal/testdeps",
-		)
-	}
-	// Add some packages required by GopherJS as imports.
-	pkg.Imports = append(pkg.Imports,
-		"github.com/gopherjs/gopherjs/js",
-		"github.com/gopherjs/gopherjs/nosync")
-	return s.recursivelyBuildPackages(pkg)
-}
-
-func (s *Session) recursivelyBuildPackages(pkg *PackageData) (*ParsedPackage, error) {
+func (s *Session) buildPackages(pkg *PackageData) (*ParsedPackage, error) {
 	if parsed, ok := s.ParsedPackages[pkg.ImportPath]; ok {
 		return parsed, nil
 	}
@@ -1042,7 +1081,7 @@ func (s *Session) recursivelyBuildPackages(pkg *PackageData) (*ParsedPackage, er
 	return parsed, nil
 }
 
-func (s *Session) CompilePackage(pkg *ParsedPackage) (*compiler.Archive, error) {
+func (s *Session) compilePackages(pkg *ParsedPackage) (*compiler.Archive, error) {
 	if archive, ok := s.UpToDateArchives[pkg.ImportPath]; ok {
 		return archive, nil
 	}
@@ -1082,7 +1121,7 @@ func (s *Session) ImportResolverFor(srcDir string) func(string) (*compiler.Archi
 
 		// The archive hasn't been compiled yet so compile it with the parsed package.
 		if parsed, ok := s.ParsedPackages[path]; ok {
-			return s.CompilePackage(parsed)
+			return s.compilePackages(parsed)
 		}
 
 		return nil, fmt.Errorf(`parsed package for %q not found`, path)

internal/testmain/testmain.go

@@ -5,7 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"go/ast"
-	gobuild "go/build"
+	"go/build"
 	"go/doc"
 	"go/parser"
 	"go/token"
@@ -16,7 +16,6 @@ import (
 	"unicode"
 	"unicode/utf8"
 
-	"github.com/gopherjs/gopherjs/build"
 	"golang.org/x/tools/go/buildutil"
 )
 
@@ -66,7 +65,8 @@ func (ef ExampleFunc) Executable() bool {
 
 // TestMain is a helper type responsible for generation of the test main package.
 type TestMain struct {
-	Package    *build.PackageData
+	Package    *build.Package
+	Context    *build.Context
 	Tests      []TestFunc
 	Benchmarks []TestFunc
 	Fuzz       []TestFunc
@@ -88,7 +88,7 @@ func (tm *TestMain) Scan(fset *token.FileSet) error {
 func (tm *TestMain) scanPkg(fset *token.FileSet, files []string, loc FuncLocation) error {
 	for _, name := range files {
 		srcPath := path.Join(tm.Package.Dir, name)
-		f, err := buildutil.OpenFile(tm.Package.InternalBuildContext(), srcPath)
+		f, err := buildutil.OpenFile(tm.Context, srcPath)
 		if err != nil {
 			return fmt.Errorf("failed to open source file %q: %w", srcPath, err)
 		}
@@ -158,7 +158,7 @@ func (tm *TestMain) scanFile(f *ast.File, loc FuncLocation) error {
 }
 
 // Synthesize main package for the tests.
-func (tm *TestMain) Synthesize(fset *token.FileSet) (*build.PackageData, *ast.File, error) {
+func (tm *TestMain) Synthesize(fset *token.FileSet) (*build.Package, *ast.File, error) {
 	buf := &bytes.Buffer{}
 	if err := testmainTmpl.Execute(buf, tm); err != nil {
 		return nil, nil, fmt.Errorf("failed to generate testmain source for package %s: %w", tm.Package.ImportPath, err)
@@ -167,12 +167,10 @@ func (tm *TestMain) Synthesize(fset *token.FileSet) (*build.PackageData, *ast.Fi
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to parse testmain source for package %s: %w", tm.Package.ImportPath, err)
 	}
-	pkg := &build.PackageData{
-		Package: &gobuild.Package{
-			ImportPath: tm.Package.ImportPath + ".testmain",
-			Name:       "main",
-			GoFiles:    []string{"_testmain.go"},
-		},
+	pkg := &build.Package{
+		ImportPath: tm.Package.ImportPath + ".testmain",
+		Name:       "main",
+		GoFiles:    []string{"_testmain.go"},
 	}
 	return pkg, src, nil
 }

tool.go

@@ -4,10 +4,8 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
-	"go/ast"
 	"go/build"
 	"go/scanner"
-	"go/token"
 	"go/types"
 	"io"
 	"net"
@@ -29,7 +27,6 @@ import (
 	"github.com/gopherjs/gopherjs/build/cache"
 	"github.com/gopherjs/gopherjs/compiler"
 	"github.com/gopherjs/gopherjs/internal/sysutil"
-	"github.com/gopherjs/gopherjs/internal/testmain"
 	"github.com/neelance/sourcemap"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
@@ -147,11 +144,7 @@ func main() {
 					if err != nil {
 						return err
 					}
-					parsed, err := s.BuildPackage(pkg)
-					if err != nil {
-						return err
-					}
-					archive, err := s.CompilePackage(parsed)
+					archive, err := s.BuildProject(pkg)
 					if err != nil {
 						return err
 					}
@@ -218,11 +211,7 @@ func main() {
 					if err != nil {
 						return err
 					}
-					parsed, err := s.BuildPackage(pkg)
-					if err != nil {
-						return err
-					}
-					archive, err := s.CompilePackage(parsed)
+					archive, err := s.BuildProject(pkg)
 					if err != nil {
 						return err
 					}
@@ -378,27 +367,8 @@ func main() {
 				return err
 			}
 
-			_, err = s.BuildPackage(pkg.TestPackage())
-			if err != nil {
-				return err
-			}
-			_, err = s.BuildPackage(pkg.XTestPackage())
-			if err != nil {
-				return err
-			}
-
-			fset := token.NewFileSet()
-			tests := testmain.TestMain{Package: pkg}
-			tests.Scan(fset)
-			mainPkg, mainFile, err := tests.Synthesize(fset)
-			if err != nil {
-				return fmt.Errorf("failed to generate testmain package for %s: %w", pkg.ImportPath, err)
-			}
-			importContext := &compiler.ImportContext{
-				Packages: s.Types,
-				Import:   s.ImportResolverFor(mainPkg.Dir),
-			}
-			mainPkgArchive, err := compiler.Compile(mainPkg.ImportPath, []*ast.File{mainFile}, fset, importContext, options.Minify)
+			pkg.IsTest = true
+			mainPkgArchive, err := s.BuildProject(pkg)
 			if err != nil {
 				return fmt.Errorf("failed to compile testmain package for %s: %w", pkg.ImportPath, err)
 			}
@@ -671,11 +641,7 @@ func (fs serveCommandFileSystem) Open(requestName string) (http.File, error) {
 			buf := new(bytes.Buffer)
 			browserErrors := new(bytes.Buffer)
 			err := func() error {
-				parsed, err := s.BuildPackage(pkg)
-				if err != nil {
-					return err
-				}
-				archive, err := s.CompilePackage(parsed)
+				archive, err := s.BuildProject(pkg)
 				if err != nil {
 					return err
 				}