+++ /dev/null
-// 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) }
projects / dotfiles / .git / blobdiff