| // 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 source |
| |
| import ( |
| "context" |
| "encoding/json" |
| "fmt" |
| "go/ast" |
| "go/printer" |
| "go/token" |
| "go/types" |
| "path/filepath" |
| "regexp" |
| "sort" |
| "strconv" |
| "strings" |
| |
| "golang.org/x/tools/internal/lsp/protocol" |
| "golang.org/x/tools/internal/span" |
| errors "golang.org/x/xerrors" |
| ) |
| |
| // MappedRange provides mapped protocol.Range for a span.Range, accounting for |
| // UTF-16 code points. |
| type MappedRange struct { |
| spanRange span.Range |
| m *protocol.ColumnMapper |
| |
| // protocolRange is the result of converting the spanRange using the mapper. |
| // It is computed on-demand. |
| protocolRange *protocol.Range |
| } |
| |
| // NewMappedRange returns a MappedRange for the given start and end token.Pos. |
| func NewMappedRange(fset *token.FileSet, m *protocol.ColumnMapper, start, end token.Pos) MappedRange { |
| return MappedRange{ |
| spanRange: span.Range{ |
| FileSet: fset, |
| Start: start, |
| End: end, |
| Converter: m.Converter, |
| }, |
| m: m, |
| } |
| } |
| |
| func (s MappedRange) Range() (protocol.Range, error) { |
| if s.protocolRange == nil { |
| spn, err := s.spanRange.Span() |
| if err != nil { |
| return protocol.Range{}, err |
| } |
| prng, err := s.m.Range(spn) |
| if err != nil { |
| return protocol.Range{}, err |
| } |
| s.protocolRange = &prng |
| } |
| return *s.protocolRange, nil |
| } |
| |
| func (s MappedRange) Span() (span.Span, error) { |
| return s.spanRange.Span() |
| } |
| |
| func (s MappedRange) SpanRange() span.Range { |
| return s.spanRange |
| } |
| |
| func (s MappedRange) URI() span.URI { |
| return s.m.URI |
| } |
| |
| // GetParsedFile is a convenience function that extracts the Package and |
| // ParsedGoFile for a file in a Snapshot. pkgPolicy is one of NarrowestPackage/ |
| // WidestPackage. |
| func GetParsedFile(ctx context.Context, snapshot Snapshot, fh FileHandle, pkgPolicy PackageFilter) (Package, *ParsedGoFile, error) { |
| pkg, err := snapshot.PackageForFile(ctx, fh.URI(), TypecheckWorkspace, pkgPolicy) |
| if err != nil { |
| return nil, nil, err |
| } |
| pgh, err := pkg.File(fh.URI()) |
| return pkg, pgh, err |
| } |
| |
| func IsGenerated(ctx context.Context, snapshot Snapshot, uri span.URI) bool { |
| fh, err := snapshot.GetFile(ctx, uri) |
| if err != nil { |
| return false |
| } |
| pgf, err := snapshot.ParseGo(ctx, fh, ParseHeader) |
| if err != nil { |
| return false |
| } |
| tok := snapshot.FileSet().File(pgf.File.Pos()) |
| if tok == nil { |
| return false |
| } |
| for _, commentGroup := range pgf.File.Comments { |
| for _, comment := range commentGroup.List { |
| if matched := generatedRx.MatchString(comment.Text); matched { |
| // Check if comment is at the beginning of the line in source. |
| if pos := tok.Position(comment.Slash); pos.Column == 1 { |
| return true |
| } |
| } |
| } |
| } |
| return false |
| } |
| |
| func nodeToProtocolRange(snapshot Snapshot, pkg Package, n ast.Node) (protocol.Range, error) { |
| mrng, err := posToMappedRange(snapshot, pkg, n.Pos(), n.End()) |
| if err != nil { |
| return protocol.Range{}, err |
| } |
| return mrng.Range() |
| } |
| |
| func objToMappedRange(snapshot Snapshot, pkg Package, obj types.Object) (MappedRange, error) { |
| if pkgName, ok := obj.(*types.PkgName); ok { |
| // An imported Go package has a package-local, unqualified name. |
| // When the name matches the imported package name, there is no |
| // identifier in the import spec with the local package name. |
| // |
| // For example: |
| // import "go/ast" // name "ast" matches package name |
| // import a "go/ast" // name "a" does not match package name |
| // |
| // When the identifier does not appear in the source, have the range |
| // of the object be the import path, including quotes. |
| if pkgName.Imported().Name() == pkgName.Name() { |
| return posToMappedRange(snapshot, pkg, obj.Pos(), obj.Pos()+token.Pos(len(pkgName.Imported().Path())+2)) |
| } |
| } |
| return nameToMappedRange(snapshot, pkg, obj.Pos(), obj.Name()) |
| } |
| |
| func nameToMappedRange(snapshot Snapshot, pkg Package, pos token.Pos, name string) (MappedRange, error) { |
| return posToMappedRange(snapshot, pkg, pos, pos+token.Pos(len(name))) |
| } |
| |
| func posToMappedRange(snapshot Snapshot, pkg Package, pos, end token.Pos) (MappedRange, error) { |
| logicalFilename := snapshot.FileSet().File(pos).Position(pos).Filename |
| pgf, _, err := findFileInDeps(pkg, span.URIFromPath(logicalFilename)) |
| if err != nil { |
| return MappedRange{}, err |
| } |
| if !pos.IsValid() { |
| return MappedRange{}, errors.Errorf("invalid position for %v", pos) |
| } |
| if !end.IsValid() { |
| return MappedRange{}, errors.Errorf("invalid position for %v", end) |
| } |
| return NewMappedRange(snapshot.FileSet(), pgf.Mapper, pos, end), nil |
| } |
| |
| // Matches cgo generated comment as well as the proposed standard: |
| // https://golang.org/s/generatedcode |
| var generatedRx = regexp.MustCompile(`// .*DO NOT EDIT\.?`) |
| |
| func DetectLanguage(langID, filename string) FileKind { |
| switch langID { |
| case "go": |
| return Go |
| case "go.mod": |
| return Mod |
| case "go.sum": |
| return Sum |
| } |
| // Fallback to detecting the language based on the file extension. |
| switch filepath.Ext(filename) { |
| case ".mod": |
| return Mod |
| case ".sum": |
| return Sum |
| default: // fallback to Go |
| return Go |
| } |
| } |
| |
| func (k FileKind) String() string { |
| switch k { |
| case Mod: |
| return "go.mod" |
| case Sum: |
| return "go.sum" |
| default: |
| return "go" |
| } |
| } |
| |
| // nodeAtPos returns the index and the node whose position is contained inside |
| // the node list. |
| func nodeAtPos(nodes []ast.Node, pos token.Pos) (ast.Node, int) { |
| if nodes == nil { |
| return nil, -1 |
| } |
| for i, node := range nodes { |
| if node.Pos() <= pos && pos <= node.End() { |
| return node, i |
| } |
| } |
| return nil, -1 |
| } |
| |
| // IsInterface returns if a types.Type is an interface |
| func IsInterface(T types.Type) bool { |
| return T != nil && types.IsInterface(T) |
| } |
| |
| // FormatNode returns the "pretty-print" output for an ast node. |
| func FormatNode(fset *token.FileSet, n ast.Node) string { |
| var buf strings.Builder |
| if err := printer.Fprint(&buf, fset, n); err != nil { |
| return "" |
| } |
| return buf.String() |
| } |
| |
| // Deref returns a pointer's element type, traversing as many levels as needed. |
| // Otherwise it returns typ. |
| func Deref(typ types.Type) types.Type { |
| for { |
| p, ok := typ.Underlying().(*types.Pointer) |
| if !ok { |
| return typ |
| } |
| typ = p.Elem() |
| } |
| } |
| |
| func SortDiagnostics(d []*Diagnostic) { |
| sort.Slice(d, func(i int, j int) bool { |
| return CompareDiagnostic(d[i], d[j]) < 0 |
| }) |
| } |
| |
| func CompareDiagnostic(a, b *Diagnostic) int { |
| if r := protocol.CompareRange(a.Range, b.Range); r != 0 { |
| return r |
| } |
| if a.Source < b.Source { |
| return -1 |
| } |
| if a.Message < b.Message { |
| return -1 |
| } |
| if a.Message == b.Message { |
| return 0 |
| } |
| return 1 |
| } |
| |
| // FindPosInPackage finds the parsed file for a position in a given search |
| // package. |
| func FindPosInPackage(snapshot Snapshot, searchpkg Package, pos token.Pos) (*ParsedGoFile, Package, error) { |
| tok := snapshot.FileSet().File(pos) |
| if tok == nil { |
| return nil, nil, errors.Errorf("no file for pos in package %s", searchpkg.ID()) |
| } |
| uri := span.URIFromPath(tok.Name()) |
| |
| pgf, pkg, err := findFileInDeps(searchpkg, uri) |
| if err != nil { |
| return nil, nil, err |
| } |
| return pgf, pkg, nil |
| } |
| |
| // findFileInDeps finds uri in pkg or its dependencies. |
| func findFileInDeps(pkg Package, uri span.URI) (*ParsedGoFile, Package, error) { |
| queue := []Package{pkg} |
| seen := make(map[string]bool) |
| |
| for len(queue) > 0 { |
| pkg := queue[0] |
| queue = queue[1:] |
| seen[pkg.ID()] = true |
| |
| if pgf, err := pkg.File(uri); err == nil { |
| return pgf, pkg, nil |
| } |
| for _, dep := range pkg.Imports() { |
| if !seen[dep.ID()] { |
| queue = append(queue, dep) |
| } |
| } |
| } |
| return nil, nil, errors.Errorf("no file for %s in package %s", uri, pkg.ID()) |
| } |
| |
| // MarshalArgs encodes the given arguments to json.RawMessages. This function |
| // is used to construct arguments to a protocol.Command. |
| // |
| // Example usage: |
| // |
| // jsonArgs, err := EncodeArgs(1, "hello", true, StructuredArg{42, 12.6}) |
| // |
| func MarshalArgs(args ...interface{}) ([]json.RawMessage, error) { |
| var out []json.RawMessage |
| for _, arg := range args { |
| argJSON, err := json.Marshal(arg) |
| if err != nil { |
| return nil, err |
| } |
| out = append(out, argJSON) |
| } |
| return out, nil |
| } |
| |
| // UnmarshalArgs decodes the given json.RawMessages to the variables provided |
| // by args. Each element of args should be a pointer. |
| // |
| // Example usage: |
| // |
| // var ( |
| // num int |
| // str string |
| // bul bool |
| // structured StructuredArg |
| // ) |
| // err := UnmarshalArgs(args, &num, &str, &bul, &structured) |
| // |
| func UnmarshalArgs(jsonArgs []json.RawMessage, args ...interface{}) error { |
| if len(args) != len(jsonArgs) { |
| return fmt.Errorf("DecodeArgs: expected %d input arguments, got %d JSON arguments", len(args), len(jsonArgs)) |
| } |
| for i, arg := range args { |
| if err := json.Unmarshal(jsonArgs[i], arg); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| // ImportPath returns the unquoted import path of s, |
| // or "" if the path is not properly quoted. |
| func ImportPath(s *ast.ImportSpec) string { |
| t, err := strconv.Unquote(s.Path.Value) |
| if err != nil { |
| return "" |
| } |
| return t |
| } |
| |
| // NodeContains returns true if a node encloses a given position pos. |
| func NodeContains(n ast.Node, pos token.Pos) bool { |
| return n != nil && n.Pos() <= pos && pos <= n.End() |
| } |
| |
| // CollectScopes returns all scopes in an ast path, ordered as innermost scope |
| // first. |
| func CollectScopes(info *types.Info, path []ast.Node, pos token.Pos) []*types.Scope { |
| // scopes[i], where i<len(path), is the possibly nil Scope of path[i]. |
| var scopes []*types.Scope |
| for _, n := range path { |
| // Include *FuncType scope if pos is inside the function body. |
| switch node := n.(type) { |
| case *ast.FuncDecl: |
| if node.Body != nil && NodeContains(node.Body, pos) { |
| n = node.Type |
| } |
| case *ast.FuncLit: |
| if node.Body != nil && NodeContains(node.Body, pos) { |
| n = node.Type |
| } |
| } |
| scopes = append(scopes, info.Scopes[n]) |
| } |
| return scopes |
| } |
| |
| // Qualifier returns a function that appropriately formats a types.PkgName |
| // appearing in a *ast.File. |
| func Qualifier(f *ast.File, pkg *types.Package, info *types.Info) types.Qualifier { |
| // Construct mapping of import paths to their defined or implicit names. |
| imports := make(map[*types.Package]string) |
| for _, imp := range f.Imports { |
| var obj types.Object |
| if imp.Name != nil { |
| obj = info.Defs[imp.Name] |
| } else { |
| obj = info.Implicits[imp] |
| } |
| if pkgname, ok := obj.(*types.PkgName); ok { |
| imports[pkgname.Imported()] = pkgname.Name() |
| } |
| } |
| // Define qualifier to replace full package paths with names of the imports. |
| return func(p *types.Package) string { |
| if p == pkg { |
| return "" |
| } |
| if name, ok := imports[p]; ok { |
| return name |
| } |
| return p.Name() |
| } |
| } |
| |
| // isDirective reports whether c is a comment directive. |
| // |
| // Copied and adapted from go/src/go/ast/ast.go. |
| func isDirective(c string) bool { |
| if len(c) < 3 { |
| return false |
| } |
| if c[1] != '/' { |
| return false |
| } |
| //-style comment (no newline at the end) |
| c = c[2:] |
| if len(c) == 0 { |
| // empty line |
| return false |
| } |
| // "//line " is a line directive. |
| // (The // has been removed.) |
| if strings.HasPrefix(c, "line ") { |
| return true |
| } |
| |
| // "//[a-z0-9]+:[a-z0-9]" |
| // (The // has been removed.) |
| colon := strings.Index(c, ":") |
| if colon <= 0 || colon+1 >= len(c) { |
| return false |
| } |
| for i := 0; i <= colon+1; i++ { |
| if i == colon { |
| continue |
| } |
| b := c[i] |
| if !('a' <= b && b <= 'z' || '0' <= b && b <= '9') { |
| return false |
| } |
| } |
| return true |
| } |
| |
| // InDir checks whether path is in the file tree rooted at dir. |
| // If so, InDir returns an equivalent path relative to dir. |
| // If not, InDir returns an empty string. |
| // InDir makes some effort to succeed even in the presence of symbolic links. |
| // |
| // Copied and slightly adjusted from go/src/cmd/go/internal/search/search.go. |
| func InDir(dir, path string) bool { |
| if rel := inDirLex(path, dir); rel != "" { |
| return true |
| } |
| xpath, err := filepath.EvalSymlinks(path) |
| if err != nil || xpath == path { |
| xpath = "" |
| } else { |
| if rel := inDirLex(xpath, dir); rel != "" { |
| return true |
| } |
| } |
| |
| xdir, err := filepath.EvalSymlinks(dir) |
| if err == nil && xdir != dir { |
| if rel := inDirLex(path, xdir); rel != "" { |
| return true |
| } |
| if xpath != "" { |
| if rel := inDirLex(xpath, xdir); rel != "" { |
| return true |
| } |
| } |
| } |
| return false |
| } |
| |
| // Copied from go/src/cmd/go/internal/search/search.go. |
| // |
| // inDirLex is like inDir but only checks the lexical form of the file names. |
| // It does not consider symbolic links. |
| // TODO(rsc): This is a copy of str.HasFilePathPrefix, modified to |
| // return the suffix. Most uses of str.HasFilePathPrefix should probably |
| // be calling InDir instead. |
| func inDirLex(path, dir string) string { |
| pv := strings.ToUpper(filepath.VolumeName(path)) |
| dv := strings.ToUpper(filepath.VolumeName(dir)) |
| path = path[len(pv):] |
| dir = dir[len(dv):] |
| switch { |
| default: |
| return "" |
| case pv != dv: |
| return "" |
| case len(path) == len(dir): |
| if path == dir { |
| return "." |
| } |
| return "" |
| case dir == "": |
| return path |
| case len(path) > len(dir): |
| if dir[len(dir)-1] == filepath.Separator { |
| if path[:len(dir)] == dir { |
| return path[len(dir):] |
| } |
| return "" |
| } |
| if path[len(dir)] == filepath.Separator && path[:len(dir)] == dir { |
| if len(path) == len(dir)+1 { |
| return "." |
| } |
| return path[len(dir)+1:] |
| } |
| return "" |
| } |
| } |