mirror of
https://github.com/golang/go
synced 2024-11-18 18:44:42 -07:00
3bd20875a2
I was curious about why were logging errors during type-checking in tests, and the answer turned out to be a bit more sinister than I expected. We were getting type error messages without filepaths, so I tried to reproduce it in the playground and wasn't able to. I realized that these errors were coming from were coming from the "fixed" version of the AST that we pass to the type checker. Adding fake positions to our fake Cond statements trivially fixes the logging issue, but it does nothing to handle the fact that the error makes no sense to the user - because it applies to something that's not in the source code. I figured we have two options: (1) skip type errors for all packages with "fixed" ASTs, or (2) add something to the error messages to indicate that the source code may not match. Starting with (1) here, and if it becomes a problem, we can move to 2. All ASTs that we fix have *ast.BadExpr in them, meaning that, by definition they have parse errors which we will preferentially show those errors to users in diagnostics (so I'm not sure how to test this). Change-Id: I17733968aa15f989cdd3e4e7261c4f4fe9b97495 Reviewed-on: https://go-review.googlesource.com/c/tools/+/227557 Run-TryBot: Rebecca Stambler <rstambler@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Heschi Kreinick <heschi@google.com>
130 lines
3.1 KiB
Go
130 lines
3.1 KiB
Go
// 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 (
|
|
"go/ast"
|
|
"go/types"
|
|
|
|
"golang.org/x/tools/internal/lsp/source"
|
|
"golang.org/x/tools/internal/packagesinternal"
|
|
"golang.org/x/tools/internal/span"
|
|
errors "golang.org/x/xerrors"
|
|
)
|
|
|
|
// pkg contains the type information needed by the source package.
|
|
type pkg struct {
|
|
// ID and package path have their own types to avoid being used interchangeably.
|
|
id packageID
|
|
pkgPath packagePath
|
|
mode source.ParseMode
|
|
forTest packagePath
|
|
goFiles []*parseGoHandle
|
|
compiledGoFiles []*parseGoHandle
|
|
errors []*source.Error
|
|
imports map[packagePath]*pkg
|
|
module *packagesinternal.Module
|
|
typeErrors []types.Error
|
|
types *types.Package
|
|
typesInfo *types.Info
|
|
typesSizes types.Sizes
|
|
}
|
|
|
|
// Declare explicit types for package paths and IDs to ensure that we never use
|
|
// an ID where a path belongs, and vice versa. If we confused the two, it would
|
|
// result in confusing errors because package IDs often look like package paths.
|
|
type packageID string
|
|
type packagePath string
|
|
|
|
// Declare explicit types for files and directories to distinguish between the two.
|
|
type fileURI span.URI
|
|
type directoryURI span.URI
|
|
type viewLoadScope span.URI
|
|
|
|
func (p *pkg) ID() string {
|
|
return string(p.id)
|
|
}
|
|
|
|
func (p *pkg) PkgPath() string {
|
|
return string(p.pkgPath)
|
|
}
|
|
|
|
func (p *pkg) CompiledGoFiles() []source.ParseGoHandle {
|
|
var files []source.ParseGoHandle
|
|
for _, f := range p.compiledGoFiles {
|
|
files = append(files, f)
|
|
}
|
|
return files
|
|
}
|
|
|
|
func (p *pkg) File(uri span.URI) (source.ParseGoHandle, error) {
|
|
for _, ph := range p.compiledGoFiles {
|
|
if ph.File().Identity().URI == uri {
|
|
return ph, nil
|
|
}
|
|
}
|
|
for _, ph := range p.goFiles {
|
|
if ph.File().Identity().URI == uri {
|
|
return ph, nil
|
|
}
|
|
}
|
|
return nil, errors.Errorf("no ParseGoHandle for %s", uri)
|
|
}
|
|
|
|
func (p *pkg) GetSyntax() []*ast.File {
|
|
var syntax []*ast.File
|
|
for _, ph := range p.compiledGoFiles {
|
|
file, _, _, _, err := ph.Cached()
|
|
if err == nil {
|
|
syntax = append(syntax, file)
|
|
}
|
|
}
|
|
return syntax
|
|
}
|
|
|
|
func (p *pkg) GetErrors() []*source.Error {
|
|
return p.errors
|
|
}
|
|
|
|
func (p *pkg) GetTypes() *types.Package {
|
|
return p.types
|
|
}
|
|
|
|
func (p *pkg) GetTypesInfo() *types.Info {
|
|
return p.typesInfo
|
|
}
|
|
|
|
func (p *pkg) GetTypesSizes() types.Sizes {
|
|
return p.typesSizes
|
|
}
|
|
|
|
func (p *pkg) IsIllTyped() bool {
|
|
return p.types == nil || p.typesInfo == nil || p.typesSizes == nil
|
|
}
|
|
|
|
func (p *pkg) ForTest() string {
|
|
return string(p.forTest)
|
|
}
|
|
|
|
func (p *pkg) GetImport(pkgPath string) (source.Package, error) {
|
|
if imp := p.imports[packagePath(pkgPath)]; imp != nil {
|
|
return imp, nil
|
|
}
|
|
// Don't return a nil pointer because that still satisfies the interface.
|
|
return nil, errors.Errorf("no imported package for %s", pkgPath)
|
|
}
|
|
|
|
func (p *pkg) Imports() []source.Package {
|
|
var result []source.Package
|
|
for _, imp := range p.imports {
|
|
result = append(result, imp)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func (p *pkg) Module() *packagesinternal.Module {
|
|
return p.module
|
|
}
|