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