github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/tools/oracle/callstack.go (about)

     1  // Copyright 2013 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package oracle
     6  
     7  import (
     8  	"fmt"
     9  	"go/token"
    10  
    11  	"golang.org/x/tools/go/callgraph"
    12  	"golang.org/x/tools/go/loader"
    13  	"golang.org/x/tools/go/ssa"
    14  	"golang.org/x/tools/go/ssa/ssautil"
    15  	"golang.org/x/tools/oracle/serial"
    16  )
    17  
    18  // Callstack displays an arbitrary path from a root of the callgraph
    19  // to the function at the current position.
    20  //
    21  // The information may be misleading in a context-insensitive
    22  // analysis. e.g. the call path X->Y->Z might be infeasible if Y never
    23  // calls Z when it is called from X.  TODO(adonovan): think about UI.
    24  //
    25  // TODO(adonovan): permit user to specify a starting point other than
    26  // the analysis root.
    27  //
    28  func callstack(q *Query) error {
    29  	fset := token.NewFileSet()
    30  	lconf := loader.Config{Fset: fset, Build: q.Build}
    31  
    32  	if err := setPTAScope(&lconf, q.Scope); err != nil {
    33  		return err
    34  	}
    35  
    36  	// Load/parse/type-check the program.
    37  	lprog, err := lconf.Load()
    38  	if err != nil {
    39  		return err
    40  	}
    41  
    42  	qpos, err := parseQueryPos(lprog, q.Pos, false)
    43  	if err != nil {
    44  		return err
    45  	}
    46  
    47  	prog := ssautil.CreateProgram(lprog, 0)
    48  
    49  	ptaConfig, err := setupPTA(prog, lprog, q.PTALog, q.Reflection)
    50  	if err != nil {
    51  		return err
    52  	}
    53  
    54  	pkg := prog.Package(qpos.info.Pkg)
    55  	if pkg == nil {
    56  		return fmt.Errorf("no SSA package")
    57  	}
    58  
    59  	if !ssa.HasEnclosingFunction(pkg, qpos.path) {
    60  		return fmt.Errorf("this position is not inside a function")
    61  	}
    62  
    63  	// Defer SSA construction till after errors are reported.
    64  	prog.Build()
    65  
    66  	target := ssa.EnclosingFunction(pkg, qpos.path)
    67  	if target == nil {
    68  		return fmt.Errorf("no SSA function built for this location (dead code?)")
    69  	}
    70  
    71  	// Run the pointer analysis and build the complete call graph.
    72  	ptaConfig.BuildCallGraph = true
    73  	cg := ptrAnalysis(ptaConfig).CallGraph
    74  	cg.DeleteSyntheticNodes()
    75  
    76  	// Search for an arbitrary path from a root to the target function.
    77  	isEnd := func(n *callgraph.Node) bool { return n.Func == target }
    78  	callpath := callgraph.PathSearch(cg.Root, isEnd)
    79  	if callpath != nil {
    80  		callpath = callpath[1:] // remove synthetic edge from <root>
    81  	}
    82  
    83  	q.Fset = fset
    84  	q.result = &callstackResult{
    85  		qpos:     qpos,
    86  		target:   target,
    87  		callpath: callpath,
    88  	}
    89  	return nil
    90  }
    91  
    92  type callstackResult struct {
    93  	qpos     *queryPos
    94  	target   *ssa.Function
    95  	callpath []*callgraph.Edge
    96  }
    97  
    98  func (r *callstackResult) display(printf printfFunc) {
    99  	if r.callpath != nil {
   100  		printf(r.qpos, "Found a call path from root to %s", r.target)
   101  		printf(r.target, "%s", r.target)
   102  		for i := len(r.callpath) - 1; i >= 0; i-- {
   103  			edge := r.callpath[i]
   104  			printf(edge, "%s from %s", edge.Description(), edge.Caller.Func)
   105  		}
   106  	} else {
   107  		printf(r.target, "%s is unreachable in this analysis scope", r.target)
   108  	}
   109  }
   110  
   111  func (r *callstackResult) toSerial(res *serial.Result, fset *token.FileSet) {
   112  	var callers []serial.Caller
   113  	for i := len(r.callpath) - 1; i >= 0; i-- { // (innermost first)
   114  		edge := r.callpath[i]
   115  		callers = append(callers, serial.Caller{
   116  			Pos:    fset.Position(edge.Pos()).String(),
   117  			Caller: edge.Caller.Func.String(),
   118  			Desc:   edge.Description(),
   119  		})
   120  	}
   121  	res.Callstack = &serial.CallStack{
   122  		Pos:     fset.Position(r.target.Pos()).String(),
   123  		Target:  r.target.String(),
   124  		Callers: callers,
   125  	}
   126  }