internal/lsp/cache/check.go - tools - Git at Google

 // Copyright 2019 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.

 package cache

 import (
 	"bytes"
 	"context"
 	"fmt"
 	"go/ast"
 	"go/types"
 	"path"
 	"sort"
 	"strings"
 	"sync"

 	"golang.org/x/mod/module"
 	"golang.org/x/tools/go/packages"
 	"golang.org/x/tools/internal/event"
 	"golang.org/x/tools/internal/lsp/debug/tag"
 	"golang.org/x/tools/internal/lsp/source"
 	"golang.org/x/tools/internal/memoize"
 	"golang.org/x/tools/internal/span"
 	"golang.org/x/tools/internal/typesinternal"
 	errors "golang.org/x/xerrors"
 )

 type packageHandleKey string

 type packageHandle struct {
 	handle *memoize.Handle

 	goFiles, compiledGoFiles []*parseGoHandle

 	// mode is the mode the files were parsed in.
 	mode source.ParseMode

 	// m is the metadata associated with the package.
 	m *metadata

 	// key is the hashed key for the package.
 	key packageHandleKey
 }

 func (ph *packageHandle) packageKey() packageKey {
 	return packageKey{
 		id:   ph.m.id,
 		mode: ph.mode,
 	}
 }

 // packageData contains the data produced by type-checking a package.
 type packageData struct {
 	pkg *pkg
 	err error
 }

 // buildPackageHandle returns a packageHandle for a given package and mode.
 func (s *snapshot) buildPackageHandle(ctx context.Context, id packageID, mode source.ParseMode) (*packageHandle, error) {
 	if ph := s.getPackage(id, mode); ph != nil {
 		return ph, nil
 	}

 	// Build the packageHandle for this ID and its dependencies.
 	ph, deps, err := s.buildKey(ctx, id, mode)
 	if err != nil {
 		return nil, err
 	}

 	// Do not close over the packageHandle or the snapshot in the Bind function.
 	// This creates a cycle, which causes the finalizers to never run on the handles.
 	// The possible cycles are:
 	//
 	//     packageHandle.h.function -> packageHandle
 	//     packageHandle.h.function -> snapshot -> packageHandle
 	//

 	m := ph.m
 	key := ph.key

 	h := s.generation.Bind(key, func(ctx context.Context, arg memoize.Arg) interface{} {
 		snapshot := arg.(*snapshot)

 		// Begin loading the direct dependencies, in parallel.
 		var wg sync.WaitGroup
 		for _, dep := range deps {
 			wg.Add(1)
 			go func(dep *packageHandle) {
 				dep.check(ctx, snapshot)
 				wg.Done()
 			}(dep)
 		}

 		data := &packageData{}
 		data.pkg, data.err = typeCheck(ctx, snapshot, m, mode, deps)
 		// Make sure that the workers above have finished before we return,
 		// especially in case of cancellation.
 		wg.Wait()

 		return data
 	}, nil)
 	ph.handle = h

 	// Cache the handle in the snapshot. If a package handle has already
 	// been cached, addPackage will return the cached value. This is fine,
 	// since the original package handle above will have no references and be
 	// garbage collected.
 	ph = s.addPackageHandle(ph)

 	return ph, nil
 }

 // buildKey computes the key for a given packageHandle.
 func (s *snapshot) buildKey(ctx context.Context, id packageID, mode source.ParseMode) (*packageHandle, map[packagePath]*packageHandle, error) {
 	m := s.getMetadata(id)
 	if m == nil {
 		return nil, nil, errors.Errorf("no metadata for %s", id)
 	}
 	goFiles, err := s.parseGoHandles(ctx, m.goFiles, mode)
 	if err != nil {
 		return nil, nil, err
 	}
 	compiledGoFiles, err := s.parseGoHandles(ctx, m.compiledGoFiles, mode)
 	if err != nil {
 		return nil, nil, err
 	}
 	ph := &packageHandle{
 		m:               m,
 		goFiles:         goFiles,
 		compiledGoFiles: compiledGoFiles,
 		mode:            mode,
 	}
 	// Make sure all of the depList are sorted.
 	depList := append([]packageID{}, m.deps...)
 	sort.Slice(depList, func(i, j int) bool {
 		return depList[i] < depList[j]
 	})

 	deps := make(map[packagePath]*packageHandle)

 	// Begin computing the key by getting the depKeys for all dependencies.
 	var depKeys []packageHandleKey
 	for _, depID := range depList {
 		depHandle, err := s.buildPackageHandle(ctx, depID, s.workspaceParseMode(depID))
 		if err != nil {
 			event.Error(ctx, fmt.Sprintf("%s: no dep handle for %s", id, depID), err, tag.Snapshot.Of(s.id))
 			if ctx.Err() != nil {
 				return nil, nil, ctx.Err()
 			}
 			// One bad dependency should not prevent us from checking the entire package.
 			// Add a special key to mark a bad dependency.
 			depKeys = append(depKeys, packageHandleKey(fmt.Sprintf("%s import not found", id)))
 			continue
 		}
 		deps[depHandle.m.pkgPath] = depHandle
 		depKeys = append(depKeys, depHandle.key)
 	}
 	experimentalKey := s.View().Options().ExperimentalPackageCacheKey
 	ph.key = checkPackageKey(ctx, ph.m.id, compiledGoFiles, m.config, depKeys, mode, experimentalKey)
 	return ph, deps, nil
 }

 func (s *snapshot) workspaceParseMode(id packageID) source.ParseMode {
 	if _, ws := s.isWorkspacePackage(id); ws {
 		return source.ParseFull
 	} else {
 		return source.ParseExported
 	}
 }

 func checkPackageKey(ctx context.Context, id packageID, pghs []*parseGoHandle, cfg *packages.Config, deps []packageHandleKey, mode source.ParseMode, experimentalKey bool) packageHandleKey {
 	b := bytes.NewBuffer(nil)
 	b.WriteString(string(id))
 	if !experimentalKey {
 		// cfg was used to produce the other hashed inputs (package ID, parsed Go
 		// files, and deps). It should not otherwise affect the inputs to the type
 		// checker, so this experiment omits it. This should increase cache hits on
 		// the daemon as cfg contains the environment and working directory.
 		b.WriteString(hashConfig(cfg))
 	}
 	b.WriteByte(byte(mode))
 	for _, dep := range deps {
 		b.WriteString(string(dep))
 	}
 	for _, cgf := range pghs {
 		b.WriteString(cgf.file.FileIdentity().String())
 	}
 	return packageHandleKey(hashContents(b.Bytes()))
 }

 // hashEnv returns a hash of the snapshot's configuration.
 func hashEnv(s *snapshot) string {
 	s.view.optionsMu.Lock()
 	env := s.view.options.EnvSlice()
 	s.view.optionsMu.Unlock()

 	b := &bytes.Buffer{}
 	for _, e := range env {
 		b.WriteString(e)
 	}
 	return hashContents(b.Bytes())
 }

 // hashConfig returns the hash for the *packages.Config.
 func hashConfig(config *packages.Config) string {
 	b := bytes.NewBuffer(nil)

 	// Dir, Mode, Env, BuildFlags are the parts of the config that can change.
 	b.WriteString(config.Dir)
 	b.WriteString(string(rune(config.Mode)))

 	for _, e := range config.Env {
 		b.WriteString(e)
 	}
 	for _, f := range config.BuildFlags {
 		b.WriteString(f)
 	}
 	return hashContents(b.Bytes())
 }

 func (ph *packageHandle) Check(ctx context.Context, s source.Snapshot) (source.Package, error) {
 	return ph.check(ctx, s.(*snapshot))
 }

 func (ph *packageHandle) check(ctx context.Context, s *snapshot) (*pkg, error) {
 	v, err := ph.handle.Get(ctx, s.generation, s)
 	if err != nil {
 		return nil, err
 	}
 	data := v.(*packageData)
 	return data.pkg, data.err
 }

 func (ph *packageHandle) CompiledGoFiles() []span.URI {
 	return ph.m.compiledGoFiles
 }

 func (ph *packageHandle) ID() string {
 	return string(ph.m.id)
 }

 func (ph *packageHandle) cached(g *memoize.Generation) (*pkg, error) {
 	v := ph.handle.Cached(g)
 	if v == nil {
 		return nil, errors.Errorf("no cached type information for %s", ph.m.pkgPath)
 	}
 	data := v.(*packageData)
 	return data.pkg, data.err
 }

 func (s *snapshot) parseGoHandles(ctx context.Context, files []span.URI, mode source.ParseMode) ([]*parseGoHandle, error) {
 	pghs := make([]*parseGoHandle, 0, len(files))
 	for _, uri := range files {
 		fh, err := s.GetFile(ctx, uri)
 		if err != nil {
 			return nil, err
 		}
 		pghs = append(pghs, s.parseGoHandle(ctx, fh, mode))
 	}
 	return pghs, nil
 }

 func typeCheck(ctx context.Context, snapshot *snapshot, m *metadata, mode source.ParseMode, deps map[packagePath]*packageHandle) (*pkg, error) {
 	ctx, done := event.Start(ctx, "cache.importer.typeCheck", tag.Package.Of(string(m.id)))
 	defer done()

 	var rawErrors []error
 	for _, err := range m.errors {
 		rawErrors = append(rawErrors, err)
 	}

 	fset := snapshot.view.session.cache.fset
 	pkg := &pkg{
 		m:               m,
 		mode:            mode,
 		goFiles:         make([]*source.ParsedGoFile, len(m.goFiles)),
 		compiledGoFiles: make([]*source.ParsedGoFile, len(m.compiledGoFiles)),
 		imports:         make(map[packagePath]*pkg),
 		typesSizes:      m.typesSizes,
 		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),
 		},
 	}
 	// If this is a replaced module in the workspace, the version is
 	// meaningless, and we don't want clients to access it.
 	if m.module != nil {
 		version := m.module.Version
 		if source.IsWorkspaceModuleVersion(version) {
 			version = ""
 		}
 		pkg.version = &module.Version{
 			Path:    m.module.Path,
 			Version: version,
 		}
 	}
 	var (
 		files        = make([]*ast.File, len(m.compiledGoFiles))
 		parseErrors  = make([]error, len(m.compiledGoFiles))
 		actualErrors = make([]error, len(m.compiledGoFiles))
 		wg           sync.WaitGroup

 		mu             sync.Mutex
 		skipTypeErrors bool
 	)
 	for i, cgf := range m.compiledGoFiles {
 		wg.Add(1)
 		go func(i int, cgf span.URI) {
 			defer wg.Done()
 			fh, err := snapshot.GetFile(ctx, cgf)
 			if err != nil {
 				actualErrors[i] = err
 				return
 			}
 			pgh := snapshot.parseGoHandle(ctx, fh, mode)
 			pgf, fixed, err := snapshot.parseGo(ctx, pgh)
 			if err != nil {
 				actualErrors[i] = err
 				return
 			}
 			pkg.compiledGoFiles[i] = pgf
 			files[i], parseErrors[i], actualErrors[i] = pgf.File, pgf.ParseErr, err

 			mu.Lock()
 			skipTypeErrors = skipTypeErrors || fixed
 			mu.Unlock()
 		}(i, cgf)
 	}
 	for i, gf := range m.goFiles {
 		wg.Add(1)
 		// We need to parse the non-compiled go files, but we don't care about their errors.
 		go func(i int, gf span.URI) {
 			defer wg.Done()
 			fh, err := snapshot.GetFile(ctx, gf)
 			if err != nil {
 				return
 			}
 			pgf, _ := snapshot.ParseGo(ctx, fh, mode)
 			pkg.goFiles[i] = pgf
 		}(i, gf)
 	}
 	wg.Wait()
 	for _, err := range actualErrors {
 		if err != nil {
 			return nil, err
 		}
 	}

 	for _, e := range parseErrors {
 		if e != nil {
 			rawErrors = append(rawErrors, e)
 		}
 	}

 	var i int
 	for _, f := range files {
 		if f != nil {
 			files[i] = f
 			i++
 		}
 	}
 	files = files[:i]

 	// Use the default type information for the unsafe package.
 	if pkg.m.pkgPath == "unsafe" {
 		pkg.types = types.Unsafe
 		// Don't type check Unsafe: it's unnecessary, and doing so exposes a data
 		// race to Unsafe.completed.
 		return pkg, nil
 	} else if len(files) == 0 { // not the unsafe package, no parsed files
 		// Try to attach errors messages to the file as much as possible.
 		var found bool
 		for _, e := range rawErrors {
 			srcErr, err := sourceError(ctx, snapshot, pkg, e)
 			if err != nil {
 				continue
 			}
 			found = true
 			pkg.errors = append(pkg.errors, srcErr)
 		}
 		if found {
 			return pkg, nil
 		}
 		return nil, errors.Errorf("no parsed files for package %s, expected: %v, list errors: %v", pkg.m.pkgPath, pkg.compiledGoFiles, rawErrors)
 	} else {
 		pkg.types = types.NewPackage(string(m.pkgPath), string(m.name))
 	}

 	cfg := &types.Config{
 		Error: func(e error) {
 			// If we have fixed parse errors in any of the files,
 			// we should hide type errors, as they may be completely nonsensical.
 			if skipTypeErrors {
 				return
 			}
 			rawErrors = append(rawErrors, e)
 		},
 		Importer: importerFunc(func(pkgPath string) (*types.Package, error) {
 			// If the context was cancelled, we should abort.
 			if ctx.Err() != nil {
 				return nil, ctx.Err()
 			}
 			dep := resolveImportPath(pkgPath, pkg, deps)
 			if dep == nil {
 				return nil, errors.Errorf("no package for import %s", pkgPath)
 			}
 			if !isValidImport(m.pkgPath, dep.m.pkgPath) {
 				return nil, errors.Errorf("invalid use of internal package %s", pkgPath)
 			}
 			depPkg, err := dep.check(ctx, snapshot)
 			if err != nil {
 				return nil, err
 			}
 			pkg.imports[depPkg.m.pkgPath] = depPkg
 			return depPkg.types, nil
 		}),
 	}
 	// We want to type check cgo code if go/types supports it.
 	// We passed typecheckCgo to go/packages when we Loaded.
 	typesinternal.SetUsesCgo(cfg)

 	check := types.NewChecker(cfg, fset, pkg.types, pkg.typesInfo)

 	// Type checking errors are handled via the config, so ignore them here.
 	_ = check.Files(files)
 	// If the context was cancelled, we may have returned a ton of transient
 	// errors to the type checker. Swallow them.
 	if ctx.Err() != nil {
 		return nil, ctx.Err()
 	}

 	// We don't care about a package's errors unless we have parsed it in full.
 	if mode == source.ParseFull {
 		expandErrors(rawErrors)
 		for _, e := range rawErrors {
 			srcErr, err := sourceError(ctx, snapshot, pkg, e)
 			if err != nil {
 				event.Error(ctx, "unable to compute error positions", err, tag.Package.Of(pkg.ID()))
 				continue
 			}
 			pkg.errors = append(pkg.errors, srcErr)
 			if err, ok := e.(extendedError); ok {
 				pkg.typeErrors = append(pkg.typeErrors, err.primary)
 			}
 		}
 	}

 	return pkg, nil
 }

 type extendedError struct {
 	primary     types.Error
 	secondaries []types.Error
 }

 func (e extendedError) Error() string {
 	return e.primary.Error()
 }

 // expandErrors duplicates "secondary" errors by mapping them to their main
 // error. Some errors returned by the type checker are followed by secondary
 // errors which give more information about the error. These are errors in
 // their own right, and they are marked by starting with \t. For instance, when
 // there is a multiply-defined function, the secondary error points back to the
 // definition first noticed.
 //
 // This code associates the secondary error with its primary error, which can
 // then be used as RelatedInformation when the error becomes a diagnostic.
 func expandErrors(errs []error) []error {
 	for i := 0; i < len(errs); {
 		e, ok := errs[i].(types.Error)
 		if !ok {
 			i++
 			continue
 		}
 		enew := extendedError{
 			primary: e,
 		}
 		j := i + 1
 		for ; j < len(errs); j++ {
 			spl, ok := errs[j].(types.Error)
 			if !ok || len(spl.Msg) == 0 || spl.Msg[0] != '\t' {
 				break
 			}
 			enew.secondaries = append(enew.secondaries, spl)
 		}
 		errs[i] = enew
 		i = j
 	}
 	return errs
 }

 // resolveImportPath resolves an import path in pkg to a package from deps.
 // It should produce the same results as resolveImportPath:
 // https://cs.opensource.google/go/go/+/master:src/cmd/go/internal/load/pkg.go;drc=641918ee09cb44d282a30ee8b66f99a0b63eaef9;l=990.
 func resolveImportPath(importPath string, pkg *pkg, deps map[packagePath]*packageHandle) *packageHandle {
 	if dep := deps[packagePath(importPath)]; dep != nil {
 		return dep
 	}
 	// We may be in GOPATH mode, in which case we need to check vendor dirs.
 	searchDir := path.Dir(pkg.PkgPath())
 	for {
 		vdir := packagePath(path.Join(searchDir, "vendor", importPath))
 		if vdep := deps[vdir]; vdep != nil {
 			return vdep
 		}

 		// Search until Dir doesn't take us anywhere new, e.g. "." or "/".
 		next := path.Dir(searchDir)
 		if searchDir == next {
 			break
 		}
 		searchDir = next
 	}

 	// Vendor didn't work. Let's try minimal module compatibility mode.
 	// In MMC, the packagePath is the canonical (.../vN/...) path, which
 	// is hard to calculate. But the go command has already resolved the ID
 	// to the non-versioned path, and we can take advantage of that.
 	for _, dep := range deps {
 		if dep.ID() == importPath {
 			return dep
 		}
 	}
 	return nil
 }

 func isValidImport(pkgPath, importPkgPath packagePath) bool {
 	i := strings.LastIndex(string(importPkgPath), "/internal/")
 	if i == -1 {
 		return true
 	}
 	if pkgPath == "command-line-arguments" {
 		return true
 	}
 	return strings.HasPrefix(string(pkgPath), string(importPkgPath[:i]))
 }

 // An importFunc is an implementation of the single-method
 // types.Importer interface based on a function value.
 type importerFunc func(path string) (*types.Package, error)

 func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
	// Copyright 2019 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.

	package cache

	import (
	"bytes"
	"context"
	"fmt"
	"go/ast"
	"go/types"
	"path"
	"sort"
	"strings"
	"sync"

	"golang.org/x/mod/module"
	"golang.org/x/tools/go/packages"
	"golang.org/x/tools/internal/event"
	"golang.org/x/tools/internal/lsp/debug/tag"
	"golang.org/x/tools/internal/lsp/source"
	"golang.org/x/tools/internal/memoize"
	"golang.org/x/tools/internal/span"
	"golang.org/x/tools/internal/typesinternal"
	errors "golang.org/x/xerrors"
	)

	type packageHandleKey string

	type packageHandle struct {
	handle *memoize.Handle

	goFiles, compiledGoFiles []*parseGoHandle

	// mode is the mode the files were parsed in.
	mode source.ParseMode

	// m is the metadata associated with the package.
	m *metadata

	// key is the hashed key for the package.
	key packageHandleKey
	}

	func (ph *packageHandle) packageKey() packageKey {
	return packageKey{
	id: ph.m.id,
	mode: ph.mode,
	}
	}

	// packageData contains the data produced by type-checking a package.
	type packageData struct {
	pkg *pkg
	err error
	}

	// buildPackageHandle returns a packageHandle for a given package and mode.
	func (s snapshot) buildPackageHandle(ctx context.Context, id packageID, mode source.ParseMode) (packageHandle, error) {
	if ph := s.getPackage(id, mode); ph != nil {
	return ph, nil
	}

	// Build the packageHandle for this ID and its dependencies.
	ph, deps, err := s.buildKey(ctx, id, mode)
	if err != nil {
	return nil, err
	}

	// Do not close over the packageHandle or the snapshot in the Bind function.
	// This creates a cycle, which causes the finalizers to never run on the handles.
	// The possible cycles are:
	//
	// packageHandle.h.function -> packageHandle
	// packageHandle.h.function -> snapshot -> packageHandle
	//

	m := ph.m
	key := ph.key

	h := s.generation.Bind(key, func(ctx context.Context, arg memoize.Arg) interface{} {
	snapshot := arg.(*snapshot)

	// Begin loading the direct dependencies, in parallel.
	var wg sync.WaitGroup
	for _, dep := range deps {
	wg.Add(1)
	go func(dep *packageHandle) {
	dep.check(ctx, snapshot)
	wg.Done()
	}(dep)
	}

	data := &packageData{}
	data.pkg, data.err = typeCheck(ctx, snapshot, m, mode, deps)
	// Make sure that the workers above have finished before we return,
	// especially in case of cancellation.
	wg.Wait()

	return data
	}, nil)
	ph.handle = h

	// Cache the handle in the snapshot. If a package handle has already
	// been cached, addPackage will return the cached value. This is fine,
	// since the original package handle above will have no references and be
	// garbage collected.
	ph = s.addPackageHandle(ph)

	return ph, nil
	}

	// buildKey computes the key for a given packageHandle.
	func (s snapshot) buildKey(ctx context.Context, id packageID, mode source.ParseMode) (packageHandle, map[packagePath]*packageHandle, error) {
	m := s.getMetadata(id)
	if m == nil {
	return nil, nil, errors.Errorf("no metadata for %s", id)
	}
	goFiles, err := s.parseGoHandles(ctx, m.goFiles, mode)
	if err != nil {
	return nil, nil, err
	}
	compiledGoFiles, err := s.parseGoHandles(ctx, m.compiledGoFiles, mode)
	if err != nil {
	return nil, nil, err
	}
	ph := &packageHandle{
	m: m,
	goFiles: goFiles,
	compiledGoFiles: compiledGoFiles,
	mode: mode,
	}
	// Make sure all of the depList are sorted.
	depList := append([]packageID{}, m.deps...)
	sort.Slice(depList, func(i, j int) bool {
	return depList[i] < depList[j]
	})

	deps := make(map[packagePath]*packageHandle)

	// Begin computing the key by getting the depKeys for all dependencies.
	var depKeys []packageHandleKey
	for _, depID := range depList {
	depHandle, err := s.buildPackageHandle(ctx, depID, s.workspaceParseMode(depID))
	if err != nil {
	event.Error(ctx, fmt.Sprintf("%s: no dep handle for %s", id, depID), err, tag.Snapshot.Of(s.id))
	if ctx.Err() != nil {
	return nil, nil, ctx.Err()
	}
	// One bad dependency should not prevent us from checking the entire package.
	// Add a special key to mark a bad dependency.
	depKeys = append(depKeys, packageHandleKey(fmt.Sprintf("%s import not found", id)))
	continue
	}
	deps[depHandle.m.pkgPath] = depHandle
	depKeys = append(depKeys, depHandle.key)
	}
	experimentalKey := s.View().Options().ExperimentalPackageCacheKey
	ph.key = checkPackageKey(ctx, ph.m.id, compiledGoFiles, m.config, depKeys, mode, experimentalKey)
	return ph, deps, nil
	}

	func (s *snapshot) workspaceParseMode(id packageID) source.ParseMode {
	if _, ws := s.isWorkspacePackage(id); ws {
	return source.ParseFull
	} else {
	return source.ParseExported
	}
	}

	func checkPackageKey(ctx context.Context, id packageID, pghs []parseGoHandle, cfg packages.Config, deps []packageHandleKey, mode source.ParseMode, experimentalKey bool) packageHandleKey {
	b := bytes.NewBuffer(nil)
	b.WriteString(string(id))
	if !experimentalKey {
	// cfg was used to produce the other hashed inputs (package ID, parsed Go
	// files, and deps). It should not otherwise affect the inputs to the type
	// checker, so this experiment omits it. This should increase cache hits on
	// the daemon as cfg contains the environment and working directory.
	b.WriteString(hashConfig(cfg))
	}
	b.WriteByte(byte(mode))
	for _, dep := range deps {
	b.WriteString(string(dep))
	}
	for _, cgf := range pghs {
	b.WriteString(cgf.file.FileIdentity().String())
	}
	return packageHandleKey(hashContents(b.Bytes()))
	}

	// hashEnv returns a hash of the snapshot's configuration.
	func hashEnv(s *snapshot) string {
	s.view.optionsMu.Lock()
	env := s.view.options.EnvSlice()
	s.view.optionsMu.Unlock()

	b := &bytes.Buffer{}
	for _, e := range env {
	b.WriteString(e)
	}
	return hashContents(b.Bytes())
	}

	// hashConfig returns the hash for the *packages.Config.
	func hashConfig(config *packages.Config) string {
	b := bytes.NewBuffer(nil)

	// Dir, Mode, Env, BuildFlags are the parts of the config that can change.
	b.WriteString(config.Dir)
	b.WriteString(string(rune(config.Mode)))

	for _, e := range config.Env {
	b.WriteString(e)
	}
	for _, f := range config.BuildFlags {
	b.WriteString(f)
	}
	return hashContents(b.Bytes())
	}

	func (ph *packageHandle) Check(ctx context.Context, s source.Snapshot) (source.Package, error) {
	return ph.check(ctx, s.(*snapshot))
	}

	func (ph packageHandle) check(ctx context.Context, s snapshot) (*pkg, error) {
	v, err := ph.handle.Get(ctx, s.generation, s)
	if err != nil {
	return nil, err
	}
	data := v.(*packageData)
	return data.pkg, data.err
	}

	func (ph *packageHandle) CompiledGoFiles() []span.URI {
	return ph.m.compiledGoFiles
	}

	func (ph *packageHandle) ID() string {
	return string(ph.m.id)
	}

	func (ph packageHandle) cached(g memoize.Generation) (*pkg, error) {
	v := ph.handle.Cached(g)
	if v == nil {
	return nil, errors.Errorf("no cached type information for %s", ph.m.pkgPath)
	}
	data := v.(*packageData)
	return data.pkg, data.err
	}

	func (s snapshot) parseGoHandles(ctx context.Context, files []span.URI, mode source.ParseMode) ([]parseGoHandle, error) {
	pghs := make([]*parseGoHandle, 0, len(files))
	for _, uri := range files {
	fh, err := s.GetFile(ctx, uri)
	if err != nil {
	return nil, err
	}
	pghs = append(pghs, s.parseGoHandle(ctx, fh, mode))
	}
	return pghs, nil
	}

	func typeCheck(ctx context.Context, snapshot snapshot, m metadata, mode source.ParseMode, deps map[packagePath]packageHandle) (pkg, error) {
	ctx, done := event.Start(ctx, "cache.importer.typeCheck", tag.Package.Of(string(m.id)))
	defer done()

	var rawErrors []error
	for _, err := range m.errors {
	rawErrors = append(rawErrors, err)
	}

	fset := snapshot.view.session.cache.fset
	pkg := &pkg{
	m: m,
	mode: mode,
	goFiles: make([]*source.ParsedGoFile, len(m.goFiles)),
	compiledGoFiles: make([]*source.ParsedGoFile, len(m.compiledGoFiles)),
	imports: make(map[packagePath]*pkg),
	typesSizes: m.typesSizes,
	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),
	},
	}
	// If this is a replaced module in the workspace, the version is
	// meaningless, and we don't want clients to access it.
	if m.module != nil {
	version := m.module.Version
	if source.IsWorkspaceModuleVersion(version) {
	version = ""
	}
	pkg.version = &module.Version{
	Path: m.module.Path,
	Version: version,
	}
	}
	var (
	files = make([]*ast.File, len(m.compiledGoFiles))
	parseErrors = make([]error, len(m.compiledGoFiles))
	actualErrors = make([]error, len(m.compiledGoFiles))
	wg sync.WaitGroup

	mu sync.Mutex
	skipTypeErrors bool
	)
	for i, cgf := range m.compiledGoFiles {
	wg.Add(1)
	go func(i int, cgf span.URI) {
	defer wg.Done()
	fh, err := snapshot.GetFile(ctx, cgf)
	if err != nil {
	actualErrors[i] = err
	return
	}
	pgh := snapshot.parseGoHandle(ctx, fh, mode)
	pgf, fixed, err := snapshot.parseGo(ctx, pgh)
	if err != nil {
	actualErrors[i] = err
	return
	}
	pkg.compiledGoFiles[i] = pgf
	files[i], parseErrors[i], actualErrors[i] = pgf.File, pgf.ParseErr, err

	mu.Lock()
	skipTypeErrors = skipTypeErrors \|\| fixed
	mu.Unlock()
	}(i, cgf)
	}
	for i, gf := range m.goFiles {
	wg.Add(1)
	// We need to parse the non-compiled go files, but we don't care about their errors.
	go func(i int, gf span.URI) {
	defer wg.Done()
	fh, err := snapshot.GetFile(ctx, gf)
	if err != nil {
	return
	}
	pgf, _ := snapshot.ParseGo(ctx, fh, mode)
	pkg.goFiles[i] = pgf
	}(i, gf)
	}
	wg.Wait()
	for _, err := range actualErrors {
	if err != nil {
	return nil, err
	}
	}

	for _, e := range parseErrors {
	if e != nil {
	rawErrors = append(rawErrors, e)
	}
	}

	var i int
	for _, f := range files {
	if f != nil {
	files[i] = f
	i++
	}
	}
	files = files[:i]

	// Use the default type information for the unsafe package.
	if pkg.m.pkgPath == "unsafe" {
	pkg.types = types.Unsafe
	// Don't type check Unsafe: it's unnecessary, and doing so exposes a data
	// race to Unsafe.completed.
	return pkg, nil
	} else if len(files) == 0 { // not the unsafe package, no parsed files
	// Try to attach errors messages to the file as much as possible.
	var found bool
	for _, e := range rawErrors {
	srcErr, err := sourceError(ctx, snapshot, pkg, e)
	if err != nil {
	continue
	}
	found = true
	pkg.errors = append(pkg.errors, srcErr)
	}
	if found {
	return pkg, nil
	}
	return nil, errors.Errorf("no parsed files for package %s, expected: %v, list errors: %v", pkg.m.pkgPath, pkg.compiledGoFiles, rawErrors)
	} else {
	pkg.types = types.NewPackage(string(m.pkgPath), string(m.name))
	}

	cfg := &types.Config{
	Error: func(e error) {
	// If we have fixed parse errors in any of the files,
	// we should hide type errors, as they may be completely nonsensical.
	if skipTypeErrors {
	return
	}
	rawErrors = append(rawErrors, e)
	},
	Importer: importerFunc(func(pkgPath string) (*types.Package, error) {
	// If the context was cancelled, we should abort.
	if ctx.Err() != nil {
	return nil, ctx.Err()
	}
	dep := resolveImportPath(pkgPath, pkg, deps)
	if dep == nil {
	return nil, errors.Errorf("no package for import %s", pkgPath)
	}
	if !isValidImport(m.pkgPath, dep.m.pkgPath) {
	return nil, errors.Errorf("invalid use of internal package %s", pkgPath)
	}
	depPkg, err := dep.check(ctx, snapshot)
	if err != nil {
	return nil, err
	}
	pkg.imports[depPkg.m.pkgPath] = depPkg
	return depPkg.types, nil
	}),
	}
	// We want to type check cgo code if go/types supports it.
	// We passed typecheckCgo to go/packages when we Loaded.
	typesinternal.SetUsesCgo(cfg)

	check := types.NewChecker(cfg, fset, pkg.types, pkg.typesInfo)

	// Type checking errors are handled via the config, so ignore them here.
	_ = check.Files(files)
	// If the context was cancelled, we may have returned a ton of transient
	// errors to the type checker. Swallow them.
	if ctx.Err() != nil {
	return nil, ctx.Err()
	}

	// We don't care about a package's errors unless we have parsed it in full.
	if mode == source.ParseFull {
	expandErrors(rawErrors)
	for _, e := range rawErrors {
	srcErr, err := sourceError(ctx, snapshot, pkg, e)
	if err != nil {
	event.Error(ctx, "unable to compute error positions", err, tag.Package.Of(pkg.ID()))
	continue
	}
	pkg.errors = append(pkg.errors, srcErr)
	if err, ok := e.(extendedError); ok {
	pkg.typeErrors = append(pkg.typeErrors, err.primary)
	}
	}
	}

	return pkg, nil
	}

	type extendedError struct {
	primary types.Error
	secondaries []types.Error
	}

	func (e extendedError) Error() string {
	return e.primary.Error()
	}

	// expandErrors duplicates "secondary" errors by mapping them to their main
	// error. Some errors returned by the type checker are followed by secondary
	// errors which give more information about the error. These are errors in
	// their own right, and they are marked by starting with \t. For instance, when
	// there is a multiply-defined function, the secondary error points back to the
	// definition first noticed.
	//
	// This code associates the secondary error with its primary error, which can
	// then be used as RelatedInformation when the error becomes a diagnostic.
	func expandErrors(errs []error) []error {
	for i := 0; i < len(errs); {
	e, ok := errs[i].(types.Error)
	if !ok {
	i++
	continue
	}
	enew := extendedError{
	primary: e,
	}
	j := i + 1
	for ; j < len(errs); j++ {
	spl, ok := errs[j].(types.Error)
	if !ok \|\| len(spl.Msg) == 0 \|\| spl.Msg[0] != '\t' {
	break
	}
	enew.secondaries = append(enew.secondaries, spl)
	}
	errs[i] = enew
	i = j
	}
	return errs
	}

	// resolveImportPath resolves an import path in pkg to a package from deps.
	// It should produce the same results as resolveImportPath:
	// https://cs.opensource.google/go/go/+/master:src/cmd/go/internal/load/pkg.go;drc=641918ee09cb44d282a30ee8b66f99a0b63eaef9;l=990.
	func resolveImportPath(importPath string, pkg pkg, deps map[packagePath]packageHandle) *packageHandle {
	if dep := deps[packagePath(importPath)]; dep != nil {
	return dep
	}
	// We may be in GOPATH mode, in which case we need to check vendor dirs.
	searchDir := path.Dir(pkg.PkgPath())
	for {
	vdir := packagePath(path.Join(searchDir, "vendor", importPath))
	if vdep := deps[vdir]; vdep != nil {
	return vdep
	}

	// Search until Dir doesn't take us anywhere new, e.g. "." or "/".
	next := path.Dir(searchDir)
	if searchDir == next {
	break
	}
	searchDir = next
	}

	// Vendor didn't work. Let's try minimal module compatibility mode.
	// In MMC, the packagePath is the canonical (.../vN/...) path, which
	// is hard to calculate. But the go command has already resolved the ID
	// to the non-versioned path, and we can take advantage of that.
	for _, dep := range deps {
	if dep.ID() == importPath {
	return dep
	}
	}
	return nil
	}

	func isValidImport(pkgPath, importPkgPath packagePath) bool {
	i := strings.LastIndex(string(importPkgPath), "/internal/")
	if i == -1 {
	return true
	}
	if pkgPath == "command-line-arguments" {
	return true
	}
	return strings.HasPrefix(string(pkgPath), string(importPkgPath[:i]))
	}

	// An importFunc is an implementation of the single-method
	// types.Importer interface based on a function value.
	type importerFunc func(path string) (*types.Package, error)

	func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }