+++ /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"
- "errors"
- "fmt"
- "go/ast"
- "go/token"
- "go/types"
- "sort"
-
- "golang.org/x/tools/internal/event"
- "golang.org/x/tools/internal/lsp/protocol"
- "golang.org/x/xerrors"
-)
-
-func Implementation(ctx context.Context, snapshot Snapshot, f FileHandle, pp protocol.Position) ([]protocol.Location, error) {
- ctx, done := event.Start(ctx, "source.Implementation")
- defer done()
-
- impls, err := implementations(ctx, snapshot, f, pp)
- if err != nil {
- return nil, err
- }
- var locations []protocol.Location
- for _, impl := range impls {
- if impl.pkg == nil || len(impl.pkg.CompiledGoFiles()) == 0 {
- continue
- }
- rng, err := objToMappedRange(snapshot, impl.pkg, impl.obj)
- if err != nil {
- return nil, err
- }
- pr, err := rng.Range()
- if err != nil {
- return nil, err
- }
- locations = append(locations, protocol.Location{
- URI: protocol.URIFromSpanURI(rng.URI()),
- Range: pr,
- })
- }
- sort.Slice(locations, func(i, j int) bool {
- li, lj := locations[i], locations[j]
- if li.URI == lj.URI {
- return protocol.CompareRange(li.Range, lj.Range) < 0
- }
- return li.URI < lj.URI
- })
- return locations, nil
-}
-
-var ErrNotAType = errors.New("not a type name or method")
-
-// implementations returns the concrete implementations of the specified
-// interface, or the interfaces implemented by the specified concrete type.
-func implementations(ctx context.Context, s Snapshot, f FileHandle, pp protocol.Position) ([]qualifiedObject, error) {
- var (
- impls []qualifiedObject
- seen = make(map[token.Position]bool)
- fset = s.FileSet()
- )
-
- qos, err := qualifiedObjsAtProtocolPos(ctx, s, f, pp)
- if err != nil {
- return nil, err
- }
- for _, qo := range qos {
- var (
- queryType types.Type
- queryMethod *types.Func
- )
-
- switch obj := qo.obj.(type) {
- case *types.Func:
- queryMethod = obj
- if recv := obj.Type().(*types.Signature).Recv(); recv != nil {
- queryType = ensurePointer(recv.Type())
- }
- case *types.TypeName:
- queryType = ensurePointer(obj.Type())
- }
-
- if queryType == nil {
- return nil, ErrNotAType
- }
-
- if types.NewMethodSet(queryType).Len() == 0 {
- return nil, nil
- }
-
- // Find all named types, even local types (which can have methods
- // due to promotion).
- var (
- allNamed []*types.Named
- pkgs = make(map[*types.Package]Package)
- )
- knownPkgs, err := s.KnownPackages(ctx)
- if err != nil {
- return nil, err
- }
- for _, pkg := range knownPkgs {
- pkgs[pkg.GetTypes()] = pkg
- info := pkg.GetTypesInfo()
- for _, obj := range info.Defs {
- obj, ok := obj.(*types.TypeName)
- // We ignore aliases 'type M = N' to avoid duplicate reporting
- // of the Named type N.
- if !ok || obj.IsAlias() {
- continue
- }
- if named, ok := obj.Type().(*types.Named); ok {
- allNamed = append(allNamed, named)
- }
- }
- }
-
- // Find all the named types that match our query.
- for _, named := range allNamed {
- var (
- candObj types.Object = named.Obj()
- candType = ensurePointer(named)
- )
-
- if !concreteImplementsIntf(candType, queryType) {
- continue
- }
-
- ms := types.NewMethodSet(candType)
- if ms.Len() == 0 {
- // Skip empty interfaces.
- continue
- }
-
- // If client queried a method, look up corresponding candType method.
- if queryMethod != nil {
- sel := ms.Lookup(queryMethod.Pkg(), queryMethod.Name())
- if sel == nil {
- continue
- }
- candObj = sel.Obj()
- }
-
- pos := fset.Position(candObj.Pos())
- if candObj == queryMethod || seen[pos] {
- continue
- }
-
- seen[pos] = true
-
- impls = append(impls, qualifiedObject{
- obj: candObj,
- pkg: pkgs[candObj.Pkg()],
- })
- }
- }
-
- return impls, nil
-}
-
-// concreteImplementsIntf returns true if a is an interface type implemented by
-// concrete type b, or vice versa.
-func concreteImplementsIntf(a, b types.Type) bool {
- aIsIntf, bIsIntf := IsInterface(a), IsInterface(b)
-
- // Make sure exactly one is an interface type.
- if aIsIntf == bIsIntf {
- return false
- }
-
- // Rearrange if needed so "a" is the concrete type.
- if aIsIntf {
- a, b = b, a
- }
-
- return types.AssignableTo(a, b)
-}
-
-// ensurePointer wraps T in a *types.Pointer if T is a named, non-interface
-// type. This is useful to make sure you consider a named type's full method
-// set.
-func ensurePointer(T types.Type) types.Type {
- if _, ok := T.(*types.Named); ok && !IsInterface(T) {
- return types.NewPointer(T)
- }
-
- return T
-}
-
-type qualifiedObject struct {
- obj types.Object
-
- // pkg is the Package that contains obj's definition.
- pkg Package
-
- // node is the *ast.Ident or *ast.ImportSpec we followed to find obj, if any.
- node ast.Node
-
- // sourcePkg is the Package that contains node, if any.
- sourcePkg Package
-}
-
-var (
- errBuiltin = errors.New("builtin object")
- errNoObjectFound = errors.New("no object found")
-)
-
-// qualifiedObjsAtProtocolPos returns info for all the type.Objects
-// referenced at the given position. An object will be returned for
-// every package that the file belongs to, in every typechecking mode
-// applicable.
-func qualifiedObjsAtProtocolPos(ctx context.Context, s Snapshot, fh FileHandle, pp protocol.Position) ([]qualifiedObject, error) {
- pkgs, err := s.PackagesForFile(ctx, fh.URI(), TypecheckAll)
- if err != nil {
- return nil, err
- }
- // Check all the packages that the file belongs to.
- var qualifiedObjs []qualifiedObject
- for _, searchpkg := range pkgs {
- astFile, pos, err := getASTFile(searchpkg, fh, pp)
- if err != nil {
- return nil, err
- }
- path := pathEnclosingObjNode(astFile, pos)
- if path == nil {
- continue
- }
- var objs []types.Object
- switch leaf := path[0].(type) {
- case *ast.Ident:
- // If leaf represents an implicit type switch object or the type
- // switch "assign" variable, expand to all of the type switch's
- // implicit objects.
- if implicits, _ := typeSwitchImplicits(searchpkg, path); len(implicits) > 0 {
- objs = append(objs, implicits...)
- } else {
- obj := searchpkg.GetTypesInfo().ObjectOf(leaf)
- if obj == nil {
- return nil, xerrors.Errorf("%w for %q", errNoObjectFound, leaf.Name)
- }
- objs = append(objs, obj)
- }
- case *ast.ImportSpec:
- // Look up the implicit *types.PkgName.
- obj := searchpkg.GetTypesInfo().Implicits[leaf]
- if obj == nil {
- return nil, xerrors.Errorf("%w for import %q", errNoObjectFound, ImportPath(leaf))
- }
- objs = append(objs, obj)
- }
- // Get all of the transitive dependencies of the search package.
- pkgs := make(map[*types.Package]Package)
- var addPkg func(pkg Package)
- addPkg = func(pkg Package) {
- pkgs[pkg.GetTypes()] = pkg
- for _, imp := range pkg.Imports() {
- if _, ok := pkgs[imp.GetTypes()]; !ok {
- addPkg(imp)
- }
- }
- }
- addPkg(searchpkg)
- for _, obj := range objs {
- if obj.Parent() == types.Universe {
- return nil, xerrors.Errorf("%q: %w", obj.Name(), errBuiltin)
- }
- pkg, ok := pkgs[obj.Pkg()]
- if !ok {
- event.Error(ctx, fmt.Sprintf("no package for obj %s: %v", obj, obj.Pkg()), err)
- continue
- }
- qualifiedObjs = append(qualifiedObjs, qualifiedObject{
- obj: obj,
- pkg: pkg,
- sourcePkg: searchpkg,
- node: path[0],
- })
- }
- }
- // Return an error if no objects were found since callers will assume that
- // the slice has at least 1 element.
- if len(qualifiedObjs) == 0 {
- return nil, errNoObjectFound
- }
- return qualifiedObjs, nil
-}
-
-func getASTFile(pkg Package, f FileHandle, pos protocol.Position) (*ast.File, token.Pos, error) {
- pgf, err := pkg.File(f.URI())
- if err != nil {
- return nil, 0, err
- }
- spn, err := pgf.Mapper.PointSpan(pos)
- if err != nil {
- return nil, 0, err
- }
- rng, err := spn.Range(pgf.Mapper.Converter)
- if err != nil {
- return nil, 0, err
- }
- return pgf.File, rng.Start, nil
-}
-
-// pathEnclosingObjNode returns the AST path to the object-defining
-// node associated with pos. "Object-defining" means either an
-// *ast.Ident mapped directly to a types.Object or an ast.Node mapped
-// implicitly to a types.Object.
-func pathEnclosingObjNode(f *ast.File, pos token.Pos) []ast.Node {
- var (
- path []ast.Node
- found bool
- )
-
- ast.Inspect(f, func(n ast.Node) bool {
- if found {
- return false
- }
-
- if n == nil {
- path = path[:len(path)-1]
- return false
- }
-
- path = append(path, n)
-
- switch n := n.(type) {
- case *ast.Ident:
- // Include the position directly after identifier. This handles
- // the common case where the cursor is right after the
- // identifier the user is currently typing. Previously we
- // handled this by calling astutil.PathEnclosingInterval twice,
- // once for "pos" and once for "pos-1".
- found = n.Pos() <= pos && pos <= n.End()
- case *ast.ImportSpec:
- if n.Path.Pos() <= pos && pos < n.Path.End() {
- found = true
- // If import spec has a name, add name to path even though
- // position isn't in the name.
- if n.Name != nil {
- path = append(path, n.Name)
- }
- }
- case *ast.StarExpr:
- // Follow star expressions to the inner identifier.
- if pos == n.Star {
- pos = n.X.Pos()
- }
- case *ast.SelectorExpr:
- // If pos is on the ".", move it into the selector.
- if pos == n.X.End() {
- pos = n.Sel.Pos()
- }
- }
-
- return !found
- })
-
- if len(path) == 0 {
- return nil
- }
-
- // Reverse path so leaf is first element.
- for i := 0; i < len(path)/2; i++ {
- path[i], path[len(path)-1-i] = path[len(path)-1-i], path[i]
- }
-
- return path
-}
projects / dotfiles / .git / blobdiff