gopls/internal/cache: remove parsego.* aliases

Also, remove redundant "Parse" prefix from Full, Header.

Change-Id: Iba9e1d0f128438232e5afb8b9e2a979a61136a83
Reviewed-on: https://go-review.googlesource.com/c/tools/+/564336
Auto-Submit: Alan Donovan <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Robert Findley <[email protected]>

Author: adonovan

gopls/internal/cache/analysis.go

@@ -32,11 +32,12 @@ import (
 
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/gopls/internal/cache/metadata"
+	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/filecache"
-	"golang.org/x/tools/gopls/internal/cache/metadata"
-	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/gopls/internal/progress"
+	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/gopls/internal/settings"
 	"golang.org/x/tools/gopls/internal/util/astutil"
 	"golang.org/x/tools/gopls/internal/util/bug"
@@ -785,7 +786,7 @@ func (an *analysisNode) cacheKey() [sha256.Size]byte {
 func (an *analysisNode) run(ctx context.Context) (*analyzeSummary, error) {
 	// Parse only the "compiled" Go files.
 	// Do the computation in parallel.
-	parsed := make([]*ParsedGoFile, len(an.files))
+	parsed := make([]*parsego.File, len(an.files))
 	{
 		var group errgroup.Group
 		group.SetLimit(4) // not too much: run itself is already called in parallel
@@ -796,7 +797,7 @@ func (an *analysisNode) run(ctx context.Context) (*analyzeSummary, error) {
 				// as cached ASTs require the global FileSet.
 				// ast.Object resolution is unfortunately an implied part of the
 				// go/analysis contract.
-				pgf, err := parseGoImpl(ctx, an.fset, fh, ParseFull&^parser.SkipObjectResolution, false)
+				pgf, err := parseGoImpl(ctx, an.fset, fh, parsego.Full&^parser.SkipObjectResolution, false)
 				parsed[i] = pgf
 				return err
 			})
@@ -910,7 +911,7 @@ func (an *analysisNode) run(ctx context.Context) (*analyzeSummary, error) {
 }
 
 // Postcondition: analysisPackage.types and an.exportDeps are populated.
-func (an *analysisNode) typeCheck(parsed []*ParsedGoFile) *analysisPackage {
+func (an *analysisNode) typeCheck(parsed []*parsego.File) *analysisPackage {
 	mp := an.mp
 
 	if false { // debugging
@@ -1101,7 +1102,7 @@ func readShallowManifest(export []byte) ([]PackagePath, error) {
 type analysisPackage struct {
 	mp             *metadata.Package
 	fset           *token.FileSet // local to this package
-	parsed         []*ParsedGoFile
+	parsed         []*parsego.File
 	files          []*ast.File // same as parsed[i].File
 	types          *types.Package
 	compiles       bool // package is transitively free of list/parse/type errors

gopls/internal/cache/check.go

@@ -23,6 +23,7 @@ import (
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/tools/go/ast/astutil"
 	"golang.org/x/tools/gopls/internal/cache/metadata"
+	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/cache/typerefs"
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/filecache"
@@ -675,7 +676,7 @@ func (b *typeCheckBatch) checkPackageForImport(ctx context.Context, ph *packageH
 	// Parse the compiled go files, bypassing the parse cache as packages checked
 	// for import are unlikely to get cache hits. Additionally, we can optimize
 	// parsing slightly by not passing parser.ParseComments.
-	pgfs := make([]*ParsedGoFile, len(ph.localInputs.compiledGoFiles))
+	pgfs := make([]*parsego.File, len(ph.localInputs.compiledGoFiles))
 	{
 		var group errgroup.Group
 		// Set an arbitrary concurrency limit; we want some parallelism but don't
@@ -1271,7 +1272,7 @@ func (s *Snapshot) typerefData(ctx context.Context, id PackageID, imports map[Im
 		bug.Reportf("internal error reading typerefs data: %v", err)
 	}
 
-	pgfs, err := s.view.parseCache.parseFiles(ctx, token.NewFileSet(), ParseFull&^parser.ParseComments, true, cgfs...)
+	pgfs, err := s.view.parseCache.parseFiles(ctx, token.NewFileSet(), parsego.Full&^parser.ParseComments, true, cgfs...)
 	if err != nil {
 		return nil, err
 	}
@@ -1471,11 +1472,11 @@ func (b *typeCheckBatch) checkPackage(ctx context.Context, ph *packageHandle) (*
 	// Collect parsed files from the type check pass, capturing parse errors from
 	// compiled files.
 	var err error
-	pkg.goFiles, err = b.parseCache.parseFiles(ctx, b.fset, ParseFull, false, inputs.goFiles...)
+	pkg.goFiles, err = b.parseCache.parseFiles(ctx, b.fset, parsego.Full, false, inputs.goFiles...)
 	if err != nil {
 		return nil, err
 	}
-	pkg.compiledGoFiles, err = b.parseCache.parseFiles(ctx, b.fset, ParseFull, false, inputs.compiledGoFiles...)
+	pkg.compiledGoFiles, err = b.parseCache.parseFiles(ctx, b.fset, parsego.Full, false, inputs.compiledGoFiles...)
 	if err != nil {
 		return nil, err
 	}
@@ -1670,12 +1671,12 @@ func depsErrors(ctx context.Context, snapshot *Snapshot, mp *metadata.Package) (
 
 	// Build an index of all imports in the package.
 	type fileImport struct {
-		cgf *ParsedGoFile
+		cgf *parsego.File
 		imp *ast.ImportSpec
 	}
 	allImports := map[string][]fileImport{}
 	for _, uri := range mp.CompiledGoFiles {
-		pgf, err := parseGoURI(ctx, snapshot, uri, ParseHeader)
+		pgf, err := parseGoURI(ctx, snapshot, uri, parsego.Header)
 		if err != nil {
 			return nil, err
 		}

gopls/internal/cache/errors.go

@@ -22,6 +22,7 @@ import (
 
 	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/gopls/internal/cache/metadata"
+	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/gopls/internal/protocol/command"
@@ -464,7 +465,7 @@ func parseGoListImportCycleError(ctx context.Context, e packages.Error, mp *meta
 	// Imports have quotation marks around them.
 	circImp := strconv.Quote(importList[1])
 	for _, uri := range mp.CompiledGoFiles {
-		pgf, err := parseGoURI(ctx, fs, uri, ParseHeader)
+		pgf, err := parseGoURI(ctx, fs, uri, parsego.Header)
 		if err != nil {
 			return nil, err
 		}
@@ -497,7 +498,7 @@ func parseGoListImportCycleError(ctx context.Context, e packages.Error, mp *meta
 // It returns an error if the file could not be read.
 //
 // TODO(rfindley): eliminate this helper.
-func parseGoURI(ctx context.Context, fs file.Source, uri protocol.DocumentURI, mode parser.Mode) (*ParsedGoFile, error) {
+func parseGoURI(ctx context.Context, fs file.Source, uri protocol.DocumentURI, mode parser.Mode) (*parsego.File, error) {
 	fh, err := fs.ReadFile(ctx, uri)
 	if err != nil {
 		return nil, err

gopls/internal/cache/mod_tidy.go

@@ -16,9 +16,10 @@ import (
 	"strings"
 
 	"golang.org/x/mod/modfile"
+	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/file"
-	"golang.org/x/tools/gopls/internal/protocol/command"
 	"golang.org/x/tools/gopls/internal/protocol"
+	"golang.org/x/tools/gopls/internal/protocol/command"
 	"golang.org/x/tools/internal/diff"
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/event/tag"
@@ -281,7 +282,7 @@ func missingModuleDiagnostics(ctx context.Context, snapshot *Snapshot, pm *Parse
 			continue
 		}
 		for _, goFile := range compiledGoFiles {
-			pgf, err := snapshot.ParseGo(ctx, goFile, ParseHeader)
+			pgf, err := snapshot.ParseGo(ctx, goFile, parsego.Header)
 			if err != nil {
 				continue
 			}
@@ -461,7 +462,7 @@ func switchDirectness(req *modfile.Require, m *protocol.Mapper) ([]protocol.Text
 
 // missingModuleForImport creates an error for a given import path that comes
 // from a missing module.
-func missingModuleForImport(pgf *ParsedGoFile, imp *ast.ImportSpec, req *modfile.Require, fixes []SuggestedFix) (*Diagnostic, error) {
+func missingModuleForImport(pgf *parsego.File, imp *ast.ImportSpec, req *modfile.Require, fixes []SuggestedFix) (*Diagnostic, error) {
 	if req.Syntax == nil {
 		return nil, fmt.Errorf("no syntax for %v", req)
 	}
@@ -488,7 +489,7 @@ func missingModuleForImport(pgf *ParsedGoFile, imp *ast.ImportSpec, req *modfile
 //
 // TODO(rfindley): this should key off ImportPath.
 func parseImports(ctx context.Context, s *Snapshot, files []file.Handle) (map[string]bool, error) {
-	pgfs, err := s.view.parseCache.parseFiles(ctx, token.NewFileSet(), ParseHeader, false, files...)
+	pgfs, err := s.view.parseCache.parseFiles(ctx, token.NewFileSet(), parsego.Header, false, files...)
 	if err != nil { // e.g. context cancellation
 		return nil, err
 	}

gopls/internal/cache/parse.go

@@ -11,14 +11,14 @@ import (
 	"go/token"
 	"path/filepath"
 
-	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/cache/parsego"
+	"golang.org/x/tools/gopls/internal/file"
 )
 
 // ParseGo parses the file whose contents are provided by fh.
 // The resulting tree may have been fixed up.
 // If the file is not available, returns nil and an error.
-func (s *Snapshot) ParseGo(ctx context.Context, fh file.Handle, mode parser.Mode) (*ParsedGoFile, error) {
+func (s *Snapshot) ParseGo(ctx context.Context, fh file.Handle, mode parser.Mode) (*parsego.File, error) {
 	pgfs, err := s.view.parseCache.parseFiles(ctx, token.NewFileSet(), mode, false, fh)
 	if err != nil {
 		return nil, err
@@ -27,7 +27,7 @@ func (s *Snapshot) ParseGo(ctx context.Context, fh file.Handle, mode parser.Mode
 }
 
 // parseGoImpl parses the Go source file whose content is provided by fh.
-func parseGoImpl(ctx context.Context, fset *token.FileSet, fh file.Handle, mode parser.Mode, purgeFuncBodies bool) (*ParsedGoFile, error) {
+func parseGoImpl(ctx context.Context, fset *token.FileSet, fh file.Handle, mode parser.Mode, purgeFuncBodies bool) (*parsego.File, error) {
 	ext := filepath.Ext(fh.URI().Path())
 	if ext != ".go" && ext != "" { // files generated by cgo have no extension
 		return nil, fmt.Errorf("cannot parse non-Go file %s", fh.URI())

gopls/internal/cache/parse_cache.go

@@ -17,8 +17,8 @@ import (
 	"time"
 
 	"golang.org/x/sync/errgroup"
-	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/cache/parsego"
+	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/protocol"
 	"golang.org/x/tools/internal/memoize"
 	"golang.org/x/tools/internal/tokeninternal"
@@ -135,7 +135,7 @@ type parseKey struct {
 type parseCacheEntry struct {
 	key      parseKey
 	hash     file.Hash
-	promise  *memoize.Promise // memoize.Promise[*ParsedGoFile]
+	promise  *memoize.Promise // memoize.Promise[*parsego.File]
 	atime    uint64           // clock time of last access, for use in LRU sorting
 	walltime time.Time        // actual time of last access, for use in time-based eviction; too coarse for LRU on some systems
 	lruIndex int              // owned by the queue implementation
@@ -303,7 +303,7 @@ func (c *parseCache) allocateSpace(size int) (int, int) {
 	return base, c.nextBase
 }
 
-// parseFiles returns a ParsedGoFile for each file handle in fhs, in the
+// parseFiles returns a parsego.File for each file handle in fhs, in the
 // requested parse mode.
 //
 // For parsed files that already exists in the cache, access time will be
@@ -317,8 +317,8 @@ func (c *parseCache) allocateSpace(size int) (int, int) {
 //
 // If parseFiles returns an error, it still returns a slice,
 // but with a nil entry for each file that could not be parsed.
-func (c *parseCache) parseFiles(ctx context.Context, fset *token.FileSet, mode parser.Mode, purgeFuncBodies bool, fhs ...file.Handle) ([]*ParsedGoFile, error) {
-	pgfs := make([]*ParsedGoFile, len(fhs))
+func (c *parseCache) parseFiles(ctx context.Context, fset *token.FileSet, mode parser.Mode, purgeFuncBodies bool, fhs ...file.Handle) ([]*parsego.File, error) {
+	pgfs := make([]*parsego.File, len(fhs))
 
 	// Temporary fall-back for 32-bit systems, where reservedForParsing is too
 	// small to be viable. We don't actually support 32-bit systems, so this
@@ -351,7 +351,7 @@ func (c *parseCache) parseFiles(ctx context.Context, fset *token.FileSet, mode p
 			if err != nil {
 				return err
 			}
-			pgfs[i] = result.(*ParsedGoFile)
+			pgfs[i] = result.(*parsego.File)
 			return nil
 		})
 	}

gopls/internal/cache/parse_cache_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 	"time"
 
+	"golang.org/x/tools/gopls/internal/cache/parsego"
 	"golang.org/x/tools/gopls/internal/file"
 	"golang.org/x/tools/gopls/internal/protocol"
 )
@@ -31,12 +32,12 @@ func TestParseCache(t *testing.T) {
 	fset := token.NewFileSet()
 
 	cache := newParseCache(0)
-	pgfs1, err := cache.parseFiles(ctx, fset, ParseFull, false, fh)
+	pgfs1, err := cache.parseFiles(ctx, fset, parsego.Full, false, fh)
 	if err != nil {
 		t.Fatal(err)
 	}
 	pgf1 := pgfs1[0]
-	pgfs2, err := cache.parseFiles(ctx, fset, ParseFull, false, fh)
+	pgfs2, err := cache.parseFiles(ctx, fset, parsego.Full, false, fh)
 	pgf2 := pgfs2[0]
 	if err != nil {
 		t.Fatal(err)
@@ -50,7 +51,7 @@ func TestParseCache(t *testing.T) {
 	files := []file.Handle{fh}
 	files = append(files, dummyFileHandles(parseCacheMinFiles-1)...)
 
-	pgfs3, err := cache.parseFiles(ctx, fset, ParseFull, false, files...)
+	pgfs3, err := cache.parseFiles(ctx, fset, parsego.Full, false, files...)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -68,13 +69,13 @@ func TestParseCache(t *testing.T) {
 	// Now overwrite the cache, after which we should get new results.
 	cache.gcOnce()
 	files = dummyFileHandles(parseCacheMinFiles)
-	_, err = cache.parseFiles(ctx, fset, ParseFull, false, files...)
+	_, err = cache.parseFiles(ctx, fset, parsego.Full, false, files...)
 	if err != nil {
 		t.Fatal(err)
 	}
 	// force a GC, which should collect the recently parsed files
 	cache.gcOnce()
-	pgfs4, err := cache.parseFiles(ctx, fset, ParseFull, false, fh)
+	pgfs4, err := cache.parseFiles(ctx, fset, parsego.Full, false, fh)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -98,7 +99,7 @@ func TestParseCache_Reparsing(t *testing.T) {
 
 	// Parsing should succeed even though we overflow the padding.
 	cache := newParseCache(0)
-	_, err := cache.parseFiles(context.Background(), token.NewFileSet(), ParseFull, false, files...)
+	_, err := cache.parseFiles(context.Background(), token.NewFileSet(), parsego.Full, false, files...)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -118,7 +119,7 @@ func TestParseCache_Issue59097(t *testing.T) {
 
 	// Parsing should succeed even though we overflow the padding.
 	cache := newParseCache(0)
-	_, err := cache.parseFiles(context.Background(), token.NewFileSet(), ParseFull, false, files...)
+	_, err := cache.parseFiles(context.Background(), token.NewFileSet(), parsego.Full, false, files...)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -136,19 +137,19 @@ func TestParseCache_TimeEviction(t *testing.T) {
 	cache := newParseCache(gcDuration)
 	cache.stop() // we'll manage GC manually, for testing.
 
-	pgfs0, err := cache.parseFiles(ctx, fset, ParseFull, false, fh, fh)
+	pgfs0, err := cache.parseFiles(ctx, fset, parsego.Full, false, fh, fh)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	files := dummyFileHandles(parseCacheMinFiles)
-	_, err = cache.parseFiles(ctx, fset, ParseFull, false, files...)
+	_, err = cache.parseFiles(ctx, fset, parsego.Full, false, files...)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// Even after filling up the 'min' files, we get a cache hit for our original file.
-	pgfs1, err := cache.parseFiles(ctx, fset, ParseFull, false, fh, fh)
+	pgfs1, err := cache.parseFiles(ctx, fset, parsego.Full, false, fh, fh)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -158,14 +159,14 @@ func TestParseCache_TimeEviction(t *testing.T) {
 	}
 
 	// But after GC, we get a cache miss.
-	_, err = cache.parseFiles(ctx, fset, ParseFull, false, files...) // mark dummy files as newer
+	_, err = cache.parseFiles(ctx, fset, parsego.Full, false, files...) // mark dummy files as newer
 	if err != nil {
 		t.Fatal(err)
 	}
 	time.Sleep(gcDuration)
 	cache.gcOnce()
 
-	pgfs2, err := cache.parseFiles(ctx, fset, ParseFull, false, fh, fh)
+	pgfs2, err := cache.parseFiles(ctx, fset, parsego.Full, false, fh, fh)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -183,7 +184,7 @@ func TestParseCache_Duplicates(t *testing.T) {
 	fh := makeFakeFileHandle(uri, []byte("package p\n\nconst _ = \"foo\""))
 
 	cache := newParseCache(0)
-	pgfs, err := cache.parseFiles(ctx, token.NewFileSet(), ParseFull, false, fh, fh)
+	pgfs, err := cache.parseFiles(ctx, token.NewFileSet(), parsego.Full, false, fh, fh)
 	if err != nil {
 		t.Fatal(err)
 	}

gopls/internal/cache/parsego/parse.go

@@ -25,14 +25,14 @@ import (
 // Common parse modes; these should be reused wherever possible to increase
 // cache hits.
 const (
-	// ParseHeader specifies that the main package declaration and imports are needed.
+	// Header specifies that the main package declaration and imports are needed.
 	// This is the mode used when attempting to examine the package graph structure.
-	ParseHeader = parser.AllErrors | parser.ParseComments | parser.ImportsOnly | parser.SkipObjectResolution
+	Header = parser.AllErrors | parser.ParseComments | parser.ImportsOnly | parser.SkipObjectResolution
 
-	// ParseFull specifies the full AST is needed.
+	// Full specifies the full AST is needed.
 	// This is used for files of direct interest where the entire contents must
 	// be considered.
-	ParseFull = parser.AllErrors | parser.ParseComments | parser.SkipObjectResolution
+	Full = parser.AllErrors | parser.ParseComments | parser.SkipObjectResolution
 )
 
 // Parse parses a buffer of Go source, repairing the tree if necessary.

gopls/internal/cache/parsego/parse_test.go

@@ -32,7 +32,7 @@ func _() {
 }
 `
 
-	pgf, _ := parsego.Parse(context.Background(), token.NewFileSet(), "file://foo.go", []byte(src), parsego.ParseFull, false)
+	pgf, _ := parsego.Parse(context.Background(), token.NewFileSet(), "file://foo.go", []byte(src), parsego.Full, false)
 	fset := tokeninternal.FileSetFor(pgf.Tok)
 	ast.Inspect(pgf.File, func(n ast.Node) bool {
 		if n != nil {