compiler: factor out utility types for processing Go sources and errors.

nevkontakte · nevkontakte · commit c18a8d47ad3e · 2024-04-15T21:45:14.000+01:00
This is the first step in reducing complexity of the compiler.Compile function. The new `sources` type represents all inputs into the package compilation and simplifies extracting useful information out of them. It is designed to have little business logic of its own and serves as a convenient bridge to other packages like go/types or astrewrite. The ErrorList type is extended with utility methods that reduce verbosity of the calling code. (cherry picked from commit cb5cf57)
diff --git a/compiler/compiler.go b/compiler/compiler.go
@@ -33,22 +33,6 @@ func init() {
 	}
 }
 
-type ErrorList []error
-
-func (err ErrorList) Error() string {
-	if len(err) == 0 {
-		return "<no errors>"
-	}
-	return fmt.Sprintf("%s (and %d more errors)", err[0].Error(), len(err[1:]))
-}
-
-func (err ErrorList) Normalize() error {
-	if len(err) == 0 {
-		return nil
-	}
-	return err
-}
-
 // Archive contains intermediate build outputs of a single package.
 //
 // This is a logical equivalent of an object file in traditional compilers.
diff --git a/compiler/errors.go b/compiler/errors.go
@@ -0,0 +1,68 @@
+package compiler
+
+import (
+	"errors"
+	"fmt"
+)
+
+// ErrTooManyErrors is added to the ErrorList by the Trim method.
+var ErrTooManyErrors = errors.New("too many errors")
+
+// ErrorList wraps multiple errors as a single error.
+type ErrorList []error
+
+func (errs ErrorList) Error() string {
+	if len(errs) == 0 {
+		return "<no errors>"
+	}
+	return fmt.Sprintf("%s (and %d more errors)", errs[0].Error(), len(errs[1:]))
+}
+
+// ErrOrNil returns nil if ErrorList is empty, or the error otherwise.
+func (errs ErrorList) ErrOrNil() error {
+	if len(errs) == 0 {
+		return nil
+	}
+	return errs
+}
+
+// Append an error to the list.
+//
+// If err is an instance of ErrorList, the lists are concatenated together,
+// otherwise err is appended at the end of the list. If err is nil, the list is
+// returned unmodified.
+//
+// 	err := DoStuff()
+// 	errList := errList.Append(err)
+func (errs ErrorList) Append(err error) ErrorList {
+	if err == nil {
+		return errs
+	}
+	if err, ok := err.(ErrorList); ok {
+		return append(errs, err...)
+	}
+	return append(errs, err)
+}
+
+// AppendDistinct is similar to Append, but doesn't append the error if it has
+// the same message as the last error on the list.
+func (errs ErrorList) AppendDistinct(err error) ErrorList {
+	if l := len(errs); l > 0 {
+		if prev := errs[l-1]; prev != nil && err.Error() == prev.Error() {
+			return errs // The new error is the same as the last one, skip it.
+		}
+	}
+
+	return errs.Append(err)
+}
+
+// Trim the error list if it has more than limit errors. If the list is trimmed,
+// all extraneous errors are replaced with a single ErrTooManyErrors, making the
+// returned ErrorList length of limit+1.
+func (errs ErrorList) Trim(limit int) ErrorList {
+	if len(errs) <= limit {
+		return errs
+	}
+
+	return append(errs[:limit], ErrTooManyErrors)
+}
diff --git a/compiler/linkname.go b/compiler/linkname.go
@@ -112,7 +112,7 @@ func parseGoLinknames(fset *token.FileSet, pkgPath string, file *ast.File) ([]Go
 		}
 	}
 
-	return directives, errs.Normalize()
+	return directives, errs.ErrOrNil()
 }
 
 // goLinknameSet is a utility that enables quick lookup of whether a decl is
diff --git a/compiler/package.go b/compiler/package.go
@@ -18,7 +18,6 @@ import (
 	"github.com/gopherjs/gopherjs/compiler/internal/typeparams"
 	"github.com/gopherjs/gopherjs/compiler/typesutil"
 	"github.com/gopherjs/gopherjs/internal/experiments"
-	"github.com/neelance/astrewrite"
 	"golang.org/x/tools/go/gcexportdata"
 	"golang.org/x/tools/go/types/typeutil"
 )
@@ -108,34 +107,20 @@ type flowData struct {
 	endCase   int
 }
 
+// ImportContext provides access to information about imported packages.
 type ImportContext struct {
+	// Mapping for an absolute import path to the package type information.
 	Packages map[string]*types.Package
-	Import   func(string) (*Archive, error)
-}
-
-// packageImporter implements go/types.Importer interface.
-type packageImporter struct {
-	importContext *ImportContext
-	importError   *error // A pointer to importError in Compile.
-}
-
-func (pi packageImporter) Import(path string) (*types.Package, error) {
-	if path == "unsafe" {
-		return types.Unsafe, nil
-	}
-
-	a, err := pi.importContext.Import(path)
-	if err != nil {
-		if *pi.importError == nil {
-			// If import failed, show first error of import only (https://github.com/gopherjs/gopherjs/issues/119).
-			*pi.importError = err
-		}
-		return nil, err
-	}
-
-	return pi.importContext.Packages[a.ImportPath], nil
+	// Import returns a previously compiled Archive for a dependency package. If
+	// the Import() call was successful, the corresponding entry must be added to
+	// the Packages map.
+	Import func(importPath string) (*Archive, error)
 }
 
+// Compile the provided Go sources as a single package.
+//
+// Import path must be the absolute import path for a package. Provided sources
+// are always sorted by name to ensure reproducible JavaScript output.
 func Compile(importPath string, files []*ast.File, fileSet *token.FileSet, importContext *ImportContext, minify bool) (_ *Archive, err error) {
 	defer func() {
 		e := recover()
@@ -152,89 +137,29 @@ func Compile(importPath string, files []*ast.File, fileSet *token.FileSet, impor
 		err = bailout(fmt.Errorf("unexpected compiler panic while building package %q: %v", importPath, e))
 	}()
 
-	// Files must be in the same order to get reproducible JS
-	sort.Slice(files, func(i, j int) bool {
-		return fileSet.File(files[i].Pos()).Name() > fileSet.File(files[j].Pos()).Name()
-	})
-
-	typesInfo := &types.Info{
-		Types:      make(map[ast.Expr]types.TypeAndValue),
-		Defs:       make(map[*ast.Ident]types.Object),
-		Uses:       make(map[*ast.Ident]types.Object),
-		Implicits:  make(map[ast.Node]types.Object),
-		Selections: make(map[*ast.SelectorExpr]*types.Selection),
-		Scopes:     make(map[ast.Node]*types.Scope),
-		Instances:  make(map[*ast.Ident]types.Instance),
-	}
-
-	var errList ErrorList
-
-	// Extract all go:linkname compiler directives from the package source.
-	goLinknames := []GoLinkname{}
-	for _, file := range files {
-		found, err := parseGoLinknames(fileSet, importPath, file)
-		if err != nil {
-			if errs, ok := err.(ErrorList); ok {
-				errList = append(errList, errs...)
-			} else {
-				errList = append(errList, err)
-			}
-		}
-		goLinknames = append(goLinknames, found...)
-	}
+	srcs := sources{
+		ImportPath: importPath,
+		Files:      files,
+		FileSet:    fileSet,
+	}.Sort()
 
-	var importError error
-	var previousErr error
-	config := &types.Config{
-		Context: types.NewContext(),
-		Importer: packageImporter{
-			importContext: importContext,
-			importError:   &importError,
-		},
-		Sizes: sizes32,
-		Error: func(err error) {
-			if previousErr != nil && previousErr.Error() == err.Error() {
-				return
-			}
-			errList = append(errList, err)
-			previousErr = err
-		},
-	}
-	typesPkg, err := config.Check(importPath, fileSet, files, typesInfo)
-	if importError != nil {
-		return nil, importError
-	}
-	if errList != nil {
-		if len(errList) > 10 {
-			pos := token.NoPos
-			if last, ok := errList[9].(types.Error); ok {
-				pos = last.Pos
-			}
-			errList = append(errList[:10], types.Error{Fset: fileSet, Pos: pos, Msg: "too many errors"})
-		}
-		return nil, errList
-	}
+	tContext := types.NewContext()
+	typesInfo, typesPkg, err := srcs.TypeCheck(importContext, tContext)
 	if err != nil {
 		return nil, err
 	}
 	if genErr := typeparams.RequiresGenericsSupport(typesInfo); genErr != nil && !experiments.Env.Generics {
 		return nil, fmt.Errorf("package %s requires generics support (https://github.com/gopherjs/gopherjs/issues/1013): %w", importPath, genErr)
 	}
-	importContext.Packages[importPath] = typesPkg
+	importContext.Packages[srcs.ImportPath] = typesPkg
 
-	exportData := new(bytes.Buffer)
-	if err := gcexportdata.Write(exportData, nil, typesPkg); err != nil {
-		return nil, fmt.Errorf("failed to write export data: %v", err)
-	}
-	encodedFileSet := new(bytes.Buffer)
-	if err := fileSet.Write(json.NewEncoder(encodedFileSet).Encode); err != nil {
+	// Extract all go:linkname compiler directives from the package source.
+	goLinknames, err := srcs.ParseGoLinknames()
+	if err != nil {
 		return nil, err
 	}
 
-	simplifiedFiles := make([]*ast.File, len(files))
-	for i, file := range files {
-		simplifiedFiles[i] = astrewrite.Simplify(file, typesInfo, false)
-	}
+	srcs = srcs.Simplified(typesInfo)
 
 	isBlocking := func(f *types.Func) bool {
 		archive, err := importContext.Import(f.Pkg().Path())
@@ -251,31 +176,31 @@ func Compile(importPath string, files []*ast.File, fileSet *token.FileSet, impor
 	}
 
 	tc := typeparams.Collector{
-		TContext:  config.Context,
+		TContext:  tContext,
 		Info:      typesInfo,
 		Instances: &typeparams.PackageInstanceSets{},
 	}
-	tc.Scan(typesPkg, simplifiedFiles...)
+	tc.Scan(typesPkg, srcs.Files...)
 	instancesByObj := map[types.Object][]typeparams.Instance{}
 	for _, inst := range tc.Instances.Pkg(typesPkg).Values() {
 		instancesByObj[inst.Object] = append(instancesByObj[inst.Object], inst)
 	}
 
-	pkgInfo := analysis.AnalyzePkg(simplifiedFiles, fileSet, typesInfo, typesPkg, isBlocking)
+	pkgInfo := analysis.AnalyzePkg(srcs.Files, fileSet, typesInfo, typesPkg, isBlocking)
 	funcCtx := &funcContext{
 		FuncInfo: pkgInfo.InitFuncInfo,
 		pkgCtx: &pkgContext{
 			Info:                 pkgInfo,
 			additionalSelections: make(map[*ast.SelectorExpr]typesutil.Selection),
 
-			typesCtx:     config.Context,
+			typesCtx:     tContext,
 			pkgVars:      make(map[string]string),
 			varPtrNames:  make(map[*types.Var]string),
 			escapingVars: make(map[*types.Var]bool),
 			indentation:  1,
 			dependencies: make(map[types.Object]bool),
 			minify:       minify,
-			fileSet:      fileSet,
+			fileSet:      srcs.FileSet,
 			instanceSet:  tc.Instances,
 		},
 		allVars:     make(map[string]int),
@@ -315,7 +240,7 @@ func Compile(importPath string, files []*ast.File, fileSet *token.FileSet, impor
 
 	var functions []*ast.FuncDecl
 	var vars []*types.Var
-	for _, file := range simplifiedFiles {
+	for _, file := range srcs.Files {
 		for _, decl := range file.Decls {
 			switch d := decl.(type) {
 			case *ast.FuncDecl:
@@ -669,8 +594,17 @@ func Compile(importPath string, files []*ast.File, fileSet *token.FileSet, impor
 		return nil, funcCtx.pkgCtx.errList
 	}
 
+	exportData := new(bytes.Buffer)
+	if err := gcexportdata.Write(exportData, nil, typesPkg); err != nil {
+		return nil, fmt.Errorf("failed to write export data: %w", err)
+	}
+	encodedFileSet := new(bytes.Buffer)
+	if err := srcs.FileSet.Write(json.NewEncoder(encodedFileSet).Encode); err != nil {
+		return nil, err
+	}
+
 	return &Archive{
-		ImportPath:   importPath,
+		ImportPath:   srcs.ImportPath,
 		Name:         typesPkg.Name(),
 		Imports:      importedPaths,
 		ExportData:   exportData.Bytes(),
diff --git a/compiler/sources.go b/compiler/sources.go

Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ func parseGoLinknames(fset token.FileSet, pkgPath string, file ast.File) ([]Go`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`
`115`		`- return directives, errs.Normalize()`
	`115`	`+ return directives, errs.ErrOrNil()`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`// goLinknameSet is a utility that enables quick lookup of whether a decl is`