+++ /dev/null
-// Copyright 2013 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 main
-
-import (
- "fmt"
- "go/ast"
- "go/build"
- "go/token"
- "os"
- "path"
- "path/filepath"
- "sort"
- "strings"
-
- "golang.org/x/tools/cmd/guru/serial"
- "golang.org/x/tools/go/ast/astutil"
-)
-
-// what reports all the information about the query selection that can be
-// obtained from parsing only its containing source file.
-// It is intended to be a very low-latency query callable from GUI
-// tools, e.g. to populate a menu of options of slower queries about
-// the selected location.
-//
-func what(q *Query) error {
- qpos, err := fastQueryPos(q.Build, q.Pos)
- if err != nil {
- return err
- }
-
- // (ignore errors)
- srcdir, importPath, _ := guessImportPath(qpos.fset.File(qpos.start).Name(), q.Build)
-
- // Determine which query modes are applicable to the selection.
- enable := map[string]bool{
- "describe": true, // any syntax; always enabled
- }
-
- if qpos.end > qpos.start {
- enable["freevars"] = true // nonempty selection?
- }
-
- for _, n := range qpos.path {
- switch n := n.(type) {
- case *ast.Ident:
- enable["definition"] = true
- enable["referrers"] = true
- enable["implements"] = true
- case *ast.CallExpr:
- enable["callees"] = true
- case *ast.FuncDecl:
- enable["callers"] = true
- enable["callstack"] = true
- case *ast.SendStmt:
- enable["peers"] = true
- case *ast.UnaryExpr:
- if n.Op == token.ARROW {
- enable["peers"] = true
- }
- }
-
- // For implements, we approximate findInterestingNode.
- if _, ok := enable["implements"]; !ok {
- switch n.(type) {
- case *ast.ArrayType,
- *ast.StructType,
- *ast.FuncType,
- *ast.InterfaceType,
- *ast.MapType,
- *ast.ChanType:
- enable["implements"] = true
- }
- }
-
- // For pointsto and whicherrs, we approximate findInterestingNode.
- if _, ok := enable["pointsto"]; !ok {
- switch n.(type) {
- case ast.Stmt,
- *ast.ArrayType,
- *ast.StructType,
- *ast.FuncType,
- *ast.InterfaceType,
- *ast.MapType,
- *ast.ChanType:
- // not an expression
- enable["pointsto"] = false
- enable["whicherrs"] = false
-
- case ast.Expr, ast.Decl, *ast.ValueSpec:
- // an expression, maybe
- enable["pointsto"] = true
- enable["whicherrs"] = true
-
- default:
- // Comment, Field, KeyValueExpr, etc: ascend.
- }
- }
- }
-
- // If we don't have an exact selection, disable modes that need one.
- if !qpos.exact {
- enable["callees"] = false
- enable["pointsto"] = false
- enable["whicherrs"] = false
- enable["describe"] = false
- }
-
- var modes []string
- for mode := range enable {
- modes = append(modes, mode)
- }
- sort.Strings(modes)
-
- // Find the object referred to by the selection (if it's an
- // identifier) and report the position of each identifier
- // that refers to the same object.
- //
- // This may return spurious matches (e.g. struct fields) because
- // it uses the best-effort name resolution done by go/parser.
- var sameids []token.Pos
- var object string
- if id, ok := qpos.path[0].(*ast.Ident); ok {
- if id.Obj == nil {
- // An unresolved identifier is potentially a package name.
- // Resolve them with a simple importer (adds ~100µs).
- importer := func(imports map[string]*ast.Object, path string) (*ast.Object, error) {
- pkg, ok := imports[path]
- if !ok {
- pkg = &ast.Object{
- Kind: ast.Pkg,
- Name: filepath.Base(path), // a guess
- }
- imports[path] = pkg
- }
- return pkg, nil
- }
- f := qpos.path[len(qpos.path)-1].(*ast.File)
- ast.NewPackage(qpos.fset, map[string]*ast.File{"": f}, importer, nil)
- }
-
- if id.Obj != nil {
- object = id.Obj.Name
- decl := qpos.path[len(qpos.path)-1]
- ast.Inspect(decl, func(n ast.Node) bool {
- if n, ok := n.(*ast.Ident); ok && n.Obj == id.Obj {
- sameids = append(sameids, n.Pos())
- }
- return true
- })
- }
- }
-
- q.Output(qpos.fset, &whatResult{
- path: qpos.path,
- srcdir: srcdir,
- importPath: importPath,
- modes: modes,
- object: object,
- sameids: sameids,
- })
- return nil
-}
-
-// guessImportPath finds the package containing filename, and returns
-// its source directory (an element of $GOPATH) and its import path
-// relative to it.
-//
-// TODO(adonovan): what about _test.go files that are not part of the
-// package?
-//
-func guessImportPath(filename string, buildContext *build.Context) (srcdir, importPath string, err error) {
- absFile, err := filepath.Abs(filename)
- if err != nil {
- return "", "", fmt.Errorf("can't form absolute path of %s: %v", filename, err)
- }
-
- absFileDir := filepath.Dir(absFile)
- resolvedAbsFileDir, err := filepath.EvalSymlinks(absFileDir)
- if err != nil {
- return "", "", fmt.Errorf("can't evaluate symlinks of %s: %v", absFileDir, err)
- }
-
- segmentedAbsFileDir := segments(resolvedAbsFileDir)
- // Find the innermost directory in $GOPATH that encloses filename.
- minD := 1024
- for _, gopathDir := range buildContext.SrcDirs() {
- absDir, err := filepath.Abs(gopathDir)
- if err != nil {
- continue // e.g. non-existent dir on $GOPATH
- }
- resolvedAbsDir, err := filepath.EvalSymlinks(absDir)
- if err != nil {
- continue // e.g. non-existent dir on $GOPATH
- }
-
- d := prefixLen(segments(resolvedAbsDir), segmentedAbsFileDir)
- // If there are multiple matches,
- // prefer the innermost enclosing directory
- // (smallest d).
- if d >= 0 && d < minD {
- minD = d
- srcdir = gopathDir
- importPath = path.Join(segmentedAbsFileDir[len(segmentedAbsFileDir)-minD:]...)
- }
- }
- if srcdir == "" {
- return "", "", fmt.Errorf("directory %s is not beneath any of these GOROOT/GOPATH directories: %s",
- filepath.Dir(absFile), strings.Join(buildContext.SrcDirs(), ", "))
- }
- if importPath == "" {
- // This happens for e.g. $GOPATH/src/a.go, but
- // "" is not a valid path for (*go/build).Import.
- return "", "", fmt.Errorf("cannot load package in root of source directory %s", srcdir)
- }
- return srcdir, importPath, nil
-}
-
-func segments(path string) []string {
- return strings.Split(path, string(os.PathSeparator))
-}
-
-// prefixLen returns the length of the remainder of y if x is a prefix
-// of y, a negative number otherwise.
-func prefixLen(x, y []string) int {
- d := len(y) - len(x)
- if d >= 0 {
- for i := range x {
- if y[i] != x[i] {
- return -1 // not a prefix
- }
- }
- }
- return d
-}
-
-type whatResult struct {
- path []ast.Node
- modes []string
- srcdir string
- importPath string
- object string
- sameids []token.Pos
-}
-
-func (r *whatResult) PrintPlain(printf printfFunc) {
- for _, n := range r.path {
- printf(n, "%s", astutil.NodeDescription(n))
- }
- printf(nil, "modes: %s", r.modes)
- printf(nil, "srcdir: %s", r.srcdir)
- printf(nil, "import path: %s", r.importPath)
- for _, pos := range r.sameids {
- printf(pos, "%s", r.object)
- }
-}
-
-func (r *whatResult) JSON(fset *token.FileSet) []byte {
- var enclosing []serial.SyntaxNode
- for _, n := range r.path {
- enclosing = append(enclosing, serial.SyntaxNode{
- Description: astutil.NodeDescription(n),
- Start: fset.Position(n.Pos()).Offset,
- End: fset.Position(n.End()).Offset,
- })
- }
-
- var sameids []string
- for _, pos := range r.sameids {
- sameids = append(sameids, fset.Position(pos).String())
- }
-
- return toJSON(&serial.What{
- Modes: r.modes,
- SrcDir: r.srcdir,
- ImportPath: r.importPath,
- Enclosing: enclosing,
- Object: r.object,
- SameIDs: sameids,
- })
-}
projects / dotfiles / .git / blobdiff