| // Copyright 2014 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 | |
| // TODO(adonovan): new queries | |
| // - show all statements that may update the selected lvalue | |
| // (local, global, field, etc). | |
| // - show all places where an object of type T is created | |
| // (&T{}, var t T, new(T), new(struct{array [3]T}), etc. | |
| import ( | |
| "encoding/json" | |
| "fmt" | |
| "go/ast" | |
| "go/build" | |
| "go/parser" | |
| "go/token" | |
| "go/types" | |
| "io" | |
| "log" | |
| "path/filepath" | |
| "strings" | |
| "golang.org/x/tools/go/ast/astutil" | |
| "golang.org/x/tools/go/buildutil" | |
| "golang.org/x/tools/go/loader" | |
| "golang.org/x/tools/go/pointer" | |
| "golang.org/x/tools/go/ssa" | |
| ) | |
| type printfFunc func(pos interface{}, format string, args ...interface{}) | |
| // A QueryResult is an item of output. Each query produces a stream of | |
| // query results, calling Query.Output for each one. | |
| type QueryResult interface { | |
| // JSON returns the QueryResult in JSON form. | |
| JSON(fset *token.FileSet) []byte | |
| // PrintPlain prints the QueryResult in plain text form. | |
| // The implementation calls printfFunc to print each line of output. | |
| PrintPlain(printf printfFunc) | |
| } | |
| // A QueryPos represents the position provided as input to a query: | |
| // a textual extent in the program's source code, the AST node it | |
| // corresponds to, and the package to which it belongs. | |
| // Instances are created by parseQueryPos. | |
| type queryPos struct { | |
| fset *token.FileSet | |
| start, end token.Pos // source extent of query | |
| path []ast.Node // AST path from query node to root of ast.File | |
| exact bool // 2nd result of PathEnclosingInterval | |
| info *loader.PackageInfo // type info for the queried package (nil for fastQueryPos) | |
| } | |
| // TypeString prints type T relative to the query position. | |
| func (qpos *queryPos) typeString(T types.Type) string { | |
| return types.TypeString(T, types.RelativeTo(qpos.info.Pkg)) | |
| } | |
| // ObjectString prints object obj relative to the query position. | |
| func (qpos *queryPos) objectString(obj types.Object) string { | |
| return types.ObjectString(obj, types.RelativeTo(qpos.info.Pkg)) | |
| } | |
| // A Query specifies a single guru query. | |
| type Query struct { | |
| Pos string // query position | |
| Build *build.Context // package loading configuration | |
| // pointer analysis options | |
| Scope []string // main packages in (*loader.Config).FromArgs syntax | |
| PTALog io.Writer // (optional) pointer-analysis log file | |
| Reflection bool // model reflection soundly (currently slow). | |
| // result-printing function, safe for concurrent use | |
| Output func(*token.FileSet, QueryResult) | |
| } | |
| // Run runs an guru query and populates its Fset and Result. | |
| func Run(mode string, q *Query) error { | |
| switch mode { | |
| case "callees": | |
| return callees(q) | |
| case "callers": | |
| return callers(q) | |
| case "callstack": | |
| return callstack(q) | |
| case "peers": | |
| return peers(q) | |
| case "pointsto": | |
| return pointsto(q) | |
| case "whicherrs": | |
| return whicherrs(q) | |
| case "definition": | |
| return definition(q) | |
| case "describe": | |
| return describe(q) | |
| case "freevars": | |
| return freevars(q) | |
| case "implements": | |
| return implements(q) | |
| case "referrers": | |
| return referrers(q) | |
| case "what": | |
| return what(q) | |
| default: | |
| return fmt.Errorf("invalid mode: %q", mode) | |
| } | |
| } | |
| func setPTAScope(lconf *loader.Config, scope []string) error { | |
| pkgs := buildutil.ExpandPatterns(lconf.Build, scope) | |
| if len(pkgs) == 0 { | |
| return fmt.Errorf("no packages specified for pointer analysis scope") | |
| } | |
| // The value of each entry in pkgs is true, | |
| // giving ImportWithTests (not Import) semantics. | |
| lconf.ImportPkgs = pkgs | |
| return nil | |
| } | |
| // Create a pointer.Config whose scope is the initial packages of lprog | |
| // and their dependencies. | |
| func setupPTA(prog *ssa.Program, lprog *loader.Program, ptaLog io.Writer, reflection bool) (*pointer.Config, error) { | |
| // For each initial package (specified on the command line), | |
| // if it has a main function, analyze that, | |
| // otherwise analyze its tests, if any. | |
| var mains []*ssa.Package | |
| for _, info := range lprog.InitialPackages() { | |
| p := prog.Package(info.Pkg) | |
| // Add package to the pointer analysis scope. | |
| if p.Pkg.Name() == "main" && p.Func("main") != nil { | |
| mains = append(mains, p) | |
| } else if main := prog.CreateTestMainPackage(p); main != nil { | |
| mains = append(mains, main) | |
| } | |
| } | |
| if mains == nil { | |
| return nil, fmt.Errorf("analysis scope has no main and no tests") | |
| } | |
| return &pointer.Config{ | |
| Log: ptaLog, | |
| Reflection: reflection, | |
| Mains: mains, | |
| }, nil | |
| } | |
| // importQueryPackage finds the package P containing the | |
| // query position and tells conf to import it. | |
| // It returns the package's path. | |
| func importQueryPackage(pos string, conf *loader.Config) (string, error) { | |
| fqpos, err := fastQueryPos(conf.Build, pos) | |
| if err != nil { | |
| return "", err // bad query | |
| } | |
| filename := fqpos.fset.File(fqpos.start).Name() | |
| _, importPath, err := guessImportPath(filename, conf.Build) | |
| if err != nil { | |
| // Can't find GOPATH dir. | |
| // Treat the query file as its own package. | |
| importPath = "command-line-arguments" | |
| conf.CreateFromFilenames(importPath, filename) | |
| } else { | |
| // Check that it's possible to load the queried package. | |
| // (e.g. guru tests contain different 'package' decls in same dir.) | |
| // Keep consistent with logic in loader/util.go! | |
| cfg2 := *conf.Build | |
| cfg2.CgoEnabled = false | |
| bp, err := cfg2.Import(importPath, "", 0) | |
| if err != nil { | |
| return "", err // no files for package | |
| } | |
| switch pkgContainsFile(bp, filename) { | |
| case 'T': | |
| conf.ImportWithTests(importPath) | |
| case 'X': | |
| conf.ImportWithTests(importPath) | |
| importPath += "_test" // for TypeCheckFuncBodies | |
| case 'G': | |
| conf.Import(importPath) | |
| default: | |
| // This happens for ad-hoc packages like | |
| // $GOROOT/src/net/http/triv.go. | |
| return "", fmt.Errorf("package %q doesn't contain file %s", | |
| importPath, filename) | |
| } | |
| } | |
| conf.TypeCheckFuncBodies = func(p string) bool { return p == importPath } | |
| return importPath, nil | |
| } | |
| // pkgContainsFile reports whether file was among the packages Go | |
| // files, Test files, eXternal test files, or not found. | |
| func pkgContainsFile(bp *build.Package, filename string) byte { | |
| for i, files := range [][]string{bp.GoFiles, bp.TestGoFiles, bp.XTestGoFiles} { | |
| for _, file := range files { | |
| if sameFile(filepath.Join(bp.Dir, file), filename) { | |
| return "GTX"[i] | |
| } | |
| } | |
| } | |
| return 0 // not found | |
| } | |
| // ParseQueryPos parses the source query position pos and returns the | |
| // AST node of the loaded program lprog that it identifies. | |
| // If needExact, it must identify a single AST subtree; | |
| // this is appropriate for queries that allow fairly arbitrary syntax, | |
| // e.g. "describe". | |
| // | |
| func parseQueryPos(lprog *loader.Program, pos string, needExact bool) (*queryPos, error) { | |
| filename, startOffset, endOffset, err := parsePos(pos) | |
| if err != nil { | |
| return nil, err | |
| } | |
| // Find the named file among those in the loaded program. | |
| var file *token.File | |
| lprog.Fset.Iterate(func(f *token.File) bool { | |
| if sameFile(filename, f.Name()) { | |
| file = f | |
| return false // done | |
| } | |
| return true // continue | |
| }) | |
| if file == nil { | |
| return nil, fmt.Errorf("file %s not found in loaded program", filename) | |
| } | |
| start, end, err := fileOffsetToPos(file, startOffset, endOffset) | |
| if err != nil { | |
| return nil, err | |
| } | |
| info, path, exact := lprog.PathEnclosingInterval(start, end) | |
| if path == nil { | |
| return nil, fmt.Errorf("no syntax here") | |
| } | |
| if needExact && !exact { | |
| return nil, fmt.Errorf("ambiguous selection within %s", astutil.NodeDescription(path[0])) | |
| } | |
| return &queryPos{lprog.Fset, start, end, path, exact, info}, nil | |
| } | |
| // ---------- Utilities ---------- | |
| // loadWithSoftErrors calls lconf.Load, suppressing "soft" errors. (See Go issue 16530.) | |
| // TODO(adonovan): Once the loader has an option to allow soft errors, | |
| // replace calls to loadWithSoftErrors with loader calls with that parameter. | |
| func loadWithSoftErrors(lconf *loader.Config) (*loader.Program, error) { | |
| lconf.AllowErrors = true | |
| // Ideally we would just return conf.Load() here, but go/types | |
| // reports certain "soft" errors that gc does not (Go issue 14596). | |
| // As a workaround, we set AllowErrors=true and then duplicate | |
| // the loader's error checking but allow soft errors. | |
| // It would be nice if the loader API permitted "AllowErrors: soft". | |
| prog, err := lconf.Load() | |
| if err != nil { | |
| return nil, err | |
| } | |
| var errpkgs []string | |
| // Report hard errors in indirectly imported packages. | |
| for _, info := range prog.AllPackages { | |
| if containsHardErrors(info.Errors) { | |
| errpkgs = append(errpkgs, info.Pkg.Path()) | |
| } else { | |
| // Enable SSA construction for packages containing only soft errors. | |
| info.TransitivelyErrorFree = true | |
| } | |
| } | |
| if errpkgs != nil { | |
| var more string | |
| if len(errpkgs) > 3 { | |
| more = fmt.Sprintf(" and %d more", len(errpkgs)-3) | |
| errpkgs = errpkgs[:3] | |
| } | |
| return nil, fmt.Errorf("couldn't load packages due to errors: %s%s", | |
| strings.Join(errpkgs, ", "), more) | |
| } | |
| return prog, err | |
| } | |
| func containsHardErrors(errors []error) bool { | |
| for _, err := range errors { | |
| if err, ok := err.(types.Error); ok && err.Soft { | |
| continue | |
| } | |
| return true | |
| } | |
| return false | |
| } | |
| // allowErrors causes type errors to be silently ignored. | |
| // (Not suitable if SSA construction follows.) | |
| func allowErrors(lconf *loader.Config) { | |
| ctxt := *lconf.Build // copy | |
| ctxt.CgoEnabled = false | |
| lconf.Build = &ctxt | |
| lconf.AllowErrors = true | |
| // AllErrors makes the parser always return an AST instead of | |
| // bailing out after 10 errors and returning an empty ast.File. | |
| lconf.ParserMode = parser.AllErrors | |
| lconf.TypeChecker.Error = func(err error) {} | |
| } | |
| // ptrAnalysis runs the pointer analysis and returns its result. | |
| func ptrAnalysis(conf *pointer.Config) *pointer.Result { | |
| result, err := pointer.Analyze(conf) | |
| if err != nil { | |
| panic(err) // pointer analysis internal error | |
| } | |
| return result | |
| } | |
| func unparen(e ast.Expr) ast.Expr { return astutil.Unparen(e) } | |
| // deref returns a pointer's element type; otherwise it returns typ. | |
| func deref(typ types.Type) types.Type { | |
| if p, ok := typ.Underlying().(*types.Pointer); ok { | |
| return p.Elem() | |
| } | |
| return typ | |
| } | |
| // fprintf prints to w a message of the form "location: message\n" | |
| // where location is derived from pos. | |
| // | |
| // pos must be one of: | |
| // - a token.Pos, denoting a position | |
| // - an ast.Node, denoting an interval | |
| // - anything with a Pos() method: | |
| // ssa.Member, ssa.Value, ssa.Instruction, types.Object, pointer.Label, etc. | |
| // - a QueryPos, denoting the extent of the user's query. | |
| // - nil, meaning no position at all. | |
| // | |
| // The output format is is compatible with the 'gnu' | |
| // compilation-error-regexp in Emacs' compilation mode. | |
| // | |
| func fprintf(w io.Writer, fset *token.FileSet, pos interface{}, format string, args ...interface{}) { | |
| var start, end token.Pos | |
| switch pos := pos.(type) { | |
| case ast.Node: | |
| start = pos.Pos() | |
| end = pos.End() | |
| case token.Pos: | |
| start = pos | |
| end = start | |
| case *types.PkgName: | |
| // The Pos of most PkgName objects does not coincide with an identifier, | |
| // so we suppress the usual start+len(name) heuristic for types.Objects. | |
| start = pos.Pos() | |
| end = start | |
| case types.Object: | |
| start = pos.Pos() | |
| end = start + token.Pos(len(pos.Name())) // heuristic | |
| case interface { | |
| Pos() token.Pos | |
| }: | |
| start = pos.Pos() | |
| end = start | |
| case *queryPos: | |
| start = pos.start | |
| end = pos.end | |
| case nil: | |
| // no-op | |
| default: | |
| panic(fmt.Sprintf("invalid pos: %T", pos)) | |
| } | |
| if sp := fset.Position(start); start == end { | |
| // (prints "-: " for token.NoPos) | |
| fmt.Fprintf(w, "%s: ", sp) | |
| } else { | |
| ep := fset.Position(end) | |
| // The -1 below is a concession to Emacs's broken use of | |
| // inclusive (not half-open) intervals. | |
| // Other editors may not want it. | |
| // TODO(adonovan): add an -editor=vim|emacs|acme|auto | |
| // flag; auto uses EMACS=t / VIM=... / etc env vars. | |
| fmt.Fprintf(w, "%s:%d.%d-%d.%d: ", | |
| sp.Filename, sp.Line, sp.Column, ep.Line, ep.Column-1) | |
| } | |
| fmt.Fprintf(w, format, args...) | |
| io.WriteString(w, "\n") | |
| } | |
| func toJSON(x interface{}) []byte { | |
| b, err := json.MarshalIndent(x, "", "\t") | |
| if err != nil { | |
| log.Fatalf("JSON error: %v", err) | |
| } | |
| return b | |
| } |