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