go.tools/oracle: an oracle that answers questions about Go source code.
+ Tests. + Emacs integration. + Emacs integration test. + very rudimentary Vim integration. Needs some love from a Vim user. TODO (in follow-ups): - More tests would be good. We'll need to make the output order deterministic in more places. - Documentation. R=gri, crawshaw, dominik.honnef CC=golang-dev https://golang.org/cl/9502043
This commit is contained in:
Alan Donovan
parent
be2647ec01
commit
e08d89f3ed
|
|
@ -0,0 +1,50 @@
|
||||||
|
#!/bin/bash
|
||||||
|
#
|
||||||
|
# Simple test of Go oracle/Emacs integration.
|
||||||
|
# Requires that GOROOT and GOPATH are set.
|
||||||
|
# Side effect: builds and installs oracle in $GOROOT.
|
||||||
|
|
||||||
|
set -eu
|
||||||
|
|
||||||
|
[ -z "$GOROOT" ] && { echo "Error: GOROOT is unset." >&2; exit 1; }
|
||||||
|
[ -z "$GOPATH" ] && { echo "Error: GOPATH is unset." >&2; exit 1; }
|
||||||
|
|
||||||
|
log=/tmp/$(basename $0)-$$.log
|
||||||
|
thisdir=$(dirname $0)
|
||||||
|
|
||||||
|
function die() {
|
||||||
|
echo "Error: $@."
|
||||||
|
cat $log
|
||||||
|
exit 1
|
||||||
|
} >&2
|
||||||
|
|
||||||
|
trap "rm -f $log" EXIT
|
||||||
|
|
||||||
|
# Build and install oracle.
|
||||||
|
go get code.google.com/p/go.tools/cmd/oracle || die "'go get' failed"
|
||||||
|
mv -f $GOPATH/bin/oracle $GOROOT/bin/
|
||||||
|
$GOROOT/bin/oracle >$log 2>&1 || true # (prints usage and exits 1)
|
||||||
|
grep -q "Usage: oracle" $log || die "$GOROOT/bin/oracle not installed"
|
||||||
|
|
||||||
|
|
||||||
|
# Run Emacs, set the scope to the oracle tool itself,
|
||||||
|
# load ./main.go, and describe the "fmt" import.
|
||||||
|
emacs --batch --no-splash --no-window-system --no-init \
|
||||||
|
--load $GOROOT/misc/emacs/go-mode.el \
|
||||||
|
--load $thisdir/oracle.el \
|
||||||
|
--eval '
|
||||||
|
(progn
|
||||||
|
(setq go-oracle-scope "code.google.com/p/go.tools/cmd/oracle")
|
||||||
|
(find-file "'$thisdir'/main.go")
|
||||||
|
(search-forward "\"fmt\"")
|
||||||
|
(backward-char)
|
||||||
|
(go-oracle-describe)
|
||||||
|
(princ (with-current-buffer "*go-oracle*"
|
||||||
|
(buffer-substring-no-properties (point-min) (point-max))))
|
||||||
|
(kill-emacs 0))
|
||||||
|
' main.go >$log 2>&1 || die "emacs command failed"
|
||||||
|
|
||||||
|
# Check that Println is mentioned.
|
||||||
|
grep -q "fmt/print.go.*func Println" $log || die "didn't find expected lines in log; got:"
|
||||||
|
|
||||||
|
echo "PASS"
|
||||||
|
|
@ -0,0 +1,104 @@
|
||||||
|
// oracle: a tool for answering questions about Go source code.
|
||||||
|
//
|
||||||
|
// Each query prints its results to the standard output in an
|
||||||
|
// editor-friendly format. Currently this is just text in a generic
|
||||||
|
// compiler diagnostic format, but in future we could provide
|
||||||
|
// sexpr/json/python formats for the raw data so that editors can
|
||||||
|
// provide more sophisticated UIs.
|
||||||
|
//
|
||||||
|
// Every line of output is of the form "pos: text", where pos = "-" if unknown.
|
||||||
|
//
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bufio"
|
||||||
|
"flag"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"log"
|
||||||
|
"os"
|
||||||
|
"runtime"
|
||||||
|
"runtime/pprof"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/oracle"
|
||||||
|
)
|
||||||
|
|
||||||
|
// TODO(adonovan): use a format that permits spaces in filenames, and
|
||||||
|
// doesn't require shell quoting.
|
||||||
|
var posFlag = flag.String("pos", "",
|
||||||
|
"Filename and offset or extent of a syntax element about which to query, "+
|
||||||
|
"e.g. 'foo.go 123-456', 'bar.go 123'.")
|
||||||
|
|
||||||
|
var modeFlag = flag.String("mode", "",
|
||||||
|
"Mode of query to perform: callers, callees, callstack, callgraph, describe.")
|
||||||
|
|
||||||
|
var ptalogFlag = flag.String("ptalog", "pta.log",
|
||||||
|
"Location of the points-to analysis log file, or empty to disable logging.")
|
||||||
|
|
||||||
|
const usage = `Go source code oracle.
|
||||||
|
Usage: oracle [<flag> ...] [<file.go> ...] [<arg> ...]
|
||||||
|
Use -help flag to display options.
|
||||||
|
|
||||||
|
Examples:
|
||||||
|
% oracle -pos 'hello.go 123' hello.go
|
||||||
|
% oracle -pos 'hello.go 123 456' hello.go
|
||||||
|
`
|
||||||
|
|
||||||
|
var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
|
||||||
|
|
||||||
|
// TODO(adonovan): the caller must---before go/build.init
|
||||||
|
// runs---specify CGO_ENABLED=0, which entails the "!cgo" go/build
|
||||||
|
// tag, preferring (dummy) Go to native C implementations of
|
||||||
|
// cgoLookupHost et al.
|
||||||
|
|
||||||
|
func init() {
|
||||||
|
// If $GOMAXPROCS isn't set, use the full capacity of the machine.
|
||||||
|
// For small machines, use at least 4 threads.
|
||||||
|
if os.Getenv("GOMAXPROCS") == "" {
|
||||||
|
n := runtime.NumCPU()
|
||||||
|
if n < 4 {
|
||||||
|
n = 4
|
||||||
|
}
|
||||||
|
runtime.GOMAXPROCS(n)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
flag.Parse()
|
||||||
|
args := flag.Args()
|
||||||
|
|
||||||
|
if len(args) == 0 {
|
||||||
|
fmt.Fprint(os.Stderr, usage)
|
||||||
|
os.Exit(1)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set up points-to analysis log file.
|
||||||
|
var ptalog io.Writer
|
||||||
|
if *ptalogFlag != "" {
|
||||||
|
if f, err := os.Create(*ptalogFlag); err != nil {
|
||||||
|
log.Fatalf(err.Error())
|
||||||
|
} else {
|
||||||
|
buf := bufio.NewWriter(f)
|
||||||
|
ptalog = buf
|
||||||
|
defer func() {
|
||||||
|
buf.Flush()
|
||||||
|
f.Close()
|
||||||
|
}()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Profiling support.
|
||||||
|
if *cpuprofile != "" {
|
||||||
|
f, err := os.Create(*cpuprofile)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatal(err)
|
||||||
|
}
|
||||||
|
pprof.StartCPUProfile(f)
|
||||||
|
defer pprof.StopCPUProfile()
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := oracle.Main(args, *modeFlag, *posFlag, ptalog, os.Stdout, nil); err != nil {
|
||||||
|
fmt.Fprintln(os.Stderr, err.Error())
|
||||||
|
os.Exit(1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,180 @@
|
||||||
|
;;;
|
||||||
|
;;; Integration of the Go 'oracle' analysis tool into Emacs.
|
||||||
|
;;;
|
||||||
|
;;; To install the Go oracle, run:
|
||||||
|
;;; % export GOROOT=... GOPATH=...
|
||||||
|
;;; % go get code.google.com/p/go.tools/cmd/oracle
|
||||||
|
;;; % mv $GOPATH/bin/oracle $GOROOT/bin/
|
||||||
|
;;;
|
||||||
|
;;; Load this file into Emacs and set go-oracle-scope to your
|
||||||
|
;;; configuration. Then, find a file of Go source code, select an
|
||||||
|
;;; expression of interest, and press F4 (for "describe") or run one
|
||||||
|
;;; of the other go-oracle-xxx commands.
|
||||||
|
;;;
|
||||||
|
;;; TODO(adonovan): simplify installation and configuration by making
|
||||||
|
;;; oracle a subcommand of 'go tool'.
|
||||||
|
|
||||||
|
(require 'compile)
|
||||||
|
(require 'go-mode)
|
||||||
|
(require 'cl)
|
||||||
|
|
||||||
|
(defgroup go-oracle nil
|
||||||
|
"Options specific to the Go oracle."
|
||||||
|
:group 'go)
|
||||||
|
|
||||||
|
(defcustom go-oracle-command (concat (car (go-root-and-paths)) "/bin/oracle")
|
||||||
|
"The Go oracle command; the default is $GOROOT/bin/oracle."
|
||||||
|
:type 'string
|
||||||
|
:group 'go-oracle)
|
||||||
|
|
||||||
|
(defcustom go-oracle-scope ""
|
||||||
|
"The scope of the analysis. See `go-oracle-set-scope'."
|
||||||
|
:type 'string
|
||||||
|
:group 'go-oracle)
|
||||||
|
|
||||||
|
(defvar go-oracle--scope-history
|
||||||
|
nil
|
||||||
|
"History of values supplied to `go-oracle-set-scope'.")
|
||||||
|
|
||||||
|
(defun go-oracle-set-scope ()
|
||||||
|
"Sets the scope for the Go oracle, prompting the user to edit the
|
||||||
|
previous scope.
|
||||||
|
|
||||||
|
The scope specifies a set of arguments, separated by spaces.
|
||||||
|
It may be:
|
||||||
|
1) a set of packages whose main() functions will be analyzed.
|
||||||
|
2) a list of *.go filenames; they will treated like as a single
|
||||||
|
package (see #3).
|
||||||
|
3) a single package whose main() function and/or Test* functions
|
||||||
|
will be analyzed.
|
||||||
|
|
||||||
|
In the common case, this is similar to the argument(s) you would
|
||||||
|
specify to 'go build'."
|
||||||
|
(interactive)
|
||||||
|
(let ((scope (read-from-minibuffer "Go oracle scope: "
|
||||||
|
go-oracle-scope
|
||||||
|
nil
|
||||||
|
nil
|
||||||
|
'go-oracle--scope-history)))
|
||||||
|
(if (string-equal "" scope)
|
||||||
|
(error "You must specify a non-empty scope for the Go oracle"))
|
||||||
|
(setq go-oracle-scope scope)))
|
||||||
|
|
||||||
|
(defun go-oracle--run (mode)
|
||||||
|
"Run the Go oracle in the specified MODE, passing it the
|
||||||
|
selected region of the current buffer. Process the output to
|
||||||
|
replace each file name with a small hyperlink. Display the
|
||||||
|
result."
|
||||||
|
(if (not buffer-file-name)
|
||||||
|
(error "Cannot use oracle on a buffer without a file name"))
|
||||||
|
;; It's not sufficient to save a modified buffer since if
|
||||||
|
;; gofmt-before-save is on the before-save-hook, saving will
|
||||||
|
;; disturb the selected region.
|
||||||
|
(if (buffer-modified-p)
|
||||||
|
(error "Please save the buffer before invoking go-oracle"))
|
||||||
|
(if (string-equal "" go-oracle-scope)
|
||||||
|
(go-oracle-set-scope))
|
||||||
|
(let* ((filename (file-truename buffer-file-name))
|
||||||
|
(pos (if (use-region-p)
|
||||||
|
(format "%s-%s"
|
||||||
|
(1- (go--position-bytes (region-beginning)))
|
||||||
|
(1- (go--position-bytes (region-end))))
|
||||||
|
(format "%s" (1- (position-bytes (point))))))
|
||||||
|
;; This would be simpler if we could just run 'go tool oracle'.
|
||||||
|
(env-vars (go-root-and-paths))
|
||||||
|
(goroot-env (concat "GOROOT=" (car env-vars)))
|
||||||
|
(gopath-env (concat "GOPATH=" (mapconcat #'identity (cdr env-vars) ":"))))
|
||||||
|
(with-current-buffer (get-buffer-create "*go-oracle*")
|
||||||
|
(setq buffer-read-only nil)
|
||||||
|
(erase-buffer)
|
||||||
|
(insert "Go Oracle\n")
|
||||||
|
(let ((args (append (list go-oracle-command nil t nil
|
||||||
|
"-ptalog=" ; avoid writing the huge log
|
||||||
|
(format "-pos=%s %s" filename pos)
|
||||||
|
(format "-mode=%s" mode))
|
||||||
|
(split-string go-oracle-scope " " t))))
|
||||||
|
;; Log the command to *Messages*, for debugging.
|
||||||
|
(message "Command: %s:" args)
|
||||||
|
(message nil) ; clears/shrinks minibuffer
|
||||||
|
|
||||||
|
(message "Running oracle...")
|
||||||
|
;; Use dynamic binding to modify/restore the environment
|
||||||
|
(let ((process-environment (list* goroot-env gopath-env "CGO_ENABLED=0" process-environment)))
|
||||||
|
(apply #'call-process args)))
|
||||||
|
(insert "\n")
|
||||||
|
(compilation-mode)
|
||||||
|
(setq compilation-error-screen-columns nil)
|
||||||
|
(let ((w (display-buffer (current-buffer))))
|
||||||
|
(balance-windows)
|
||||||
|
(shrink-window-if-larger-than-buffer w)
|
||||||
|
(set-window-point w (point-min)))
|
||||||
|
|
||||||
|
;; Hide the file/line info to save space.
|
||||||
|
;; Replace each with a little widget.
|
||||||
|
;; compilation-mode + this loop = slooow.
|
||||||
|
;; TODO(adonovan): have oracle give us an S-expression
|
||||||
|
;; and we'll do the markup directly.
|
||||||
|
(let ((buffer-read-only nil)
|
||||||
|
(p 1))
|
||||||
|
(while (not (null p))
|
||||||
|
(let ((np (compilation-next-single-property-change p 'compilation-message)))
|
||||||
|
(message "Post-processing link (%d%%)" (/ (* p 100) (point-max)))
|
||||||
|
(if np
|
||||||
|
(when (equal (line-number-at-pos p) (line-number-at-pos np))
|
||||||
|
;; np is (typically) the space following ":"; consume it too.
|
||||||
|
(put-text-property p np 'display "▶")
|
||||||
|
(goto-char np)
|
||||||
|
(insert " ")))
|
||||||
|
(setq p np)))
|
||||||
|
(message nil)))))
|
||||||
|
|
||||||
|
(defun go-oracle-callees ()
|
||||||
|
"Show possible callees of the function call at the current point."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "callees"))
|
||||||
|
|
||||||
|
(defun go-oracle-callers ()
|
||||||
|
"Show the set of callers of the function containing the current point."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "callers"))
|
||||||
|
|
||||||
|
(defun go-oracle-callgraph ()
|
||||||
|
"Show the callgraph of the current program."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "callgraph"))
|
||||||
|
|
||||||
|
(defun go-oracle-callstack ()
|
||||||
|
"Show an arbitrary path from a root of the call graph to the
|
||||||
|
function containing the current point."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "callstack"))
|
||||||
|
|
||||||
|
(defun go-oracle-describe ()
|
||||||
|
"Describe the expression at the current point."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "describe"))
|
||||||
|
|
||||||
|
(defun go-oracle-implements ()
|
||||||
|
"Describe the 'implements' relation for types in the package
|
||||||
|
containing the current point."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "implements"))
|
||||||
|
|
||||||
|
(defun go-oracle-freevars ()
|
||||||
|
"Enumerate the free variables of the current selection."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "freevars"))
|
||||||
|
|
||||||
|
(defun go-oracle-channel-peers ()
|
||||||
|
"Enumerate the set of possible corresponding sends/receives for
|
||||||
|
this channel receive/send operation."
|
||||||
|
(interactive)
|
||||||
|
(go-oracle--run "peers"))
|
||||||
|
|
||||||
|
;; TODO(adonovan): don't mutate the keymap; just document how users
|
||||||
|
;; can do this themselves. But that means freezing the API, so don't
|
||||||
|
;; do that yet; wait till v1.0.
|
||||||
|
(add-hook 'go-mode-hook
|
||||||
|
#'(lambda () (local-set-key (kbd "<f4>") #'go-oracle-describe)))
|
||||||
|
|
||||||
|
(provide 'go-oracle)
|
||||||
|
|
@ -0,0 +1,62 @@
|
||||||
|
" -*- text -*-
|
||||||
|
" oracle.vim -- Vim integration for the Go oracle.
|
||||||
|
"
|
||||||
|
" Load with (e.g.) :source oracle.vim
|
||||||
|
" Call with (e.g.) :GoOracleDescribe
|
||||||
|
" while cursor or selection is over syntax of interest.
|
||||||
|
" Run :copen to show the quick-fix file.
|
||||||
|
"
|
||||||
|
" This is an absolutely rudimentary integration of the Go Oracle into
|
||||||
|
" Vim's quickfix mechanism and it needs a number of usability
|
||||||
|
" improvements before it can be practically useful to Vim users.
|
||||||
|
" Voluntary contributions welcomed!
|
||||||
|
"
|
||||||
|
" TODO(adonovan):
|
||||||
|
" - prompt/save the buffer if modified.
|
||||||
|
" - reject buffers with no filename.
|
||||||
|
" - hide all filenames in quickfix buffer.
|
||||||
|
|
||||||
|
|
||||||
|
" Users should customize this to their analysis scope, e.g. main package(s).
|
||||||
|
let s:scope = "/home/adonovan/go3/got/d.go"
|
||||||
|
|
||||||
|
" The path to the Go oracle executable.
|
||||||
|
let s:go_oracle = "$GOROOT/bin/oracle"
|
||||||
|
|
||||||
|
" Enable Vim to recognize GNU-style 'file:line.col-line.col: message' format.
|
||||||
|
set errorformat+=%f:%l.%c-%*[0-9].%*[0-9]:\ %m
|
||||||
|
|
||||||
|
func! s:RunOracle(mode) abort
|
||||||
|
let s:pos = line2byte(line("."))+col(".")
|
||||||
|
let s:errfile = tempname()
|
||||||
|
let s:cmd = printf("!%s -ptalog= -mode=%s '-pos=%s %d' %s >%s",
|
||||||
|
\ s:go_oracle, a:mode, bufname(""), s:pos, s:scope, s:errfile)
|
||||||
|
execute s:cmd
|
||||||
|
execute "cfile " . s:errfile
|
||||||
|
endfun
|
||||||
|
|
||||||
|
" Describe the expression at the current point.
|
||||||
|
command! GoOracleDescribe
|
||||||
|
\ call s:RunOracle("describe")
|
||||||
|
|
||||||
|
" Show possible callees of the function call at the current point.
|
||||||
|
command! GoOracleCallees
|
||||||
|
\ call s:RunOracle("callees")
|
||||||
|
|
||||||
|
" Show the set of callers of the function containing the current point.
|
||||||
|
command! GoOracleCallers
|
||||||
|
\ call s:RunOracle("callers")
|
||||||
|
|
||||||
|
" Show the callgraph of the current program.
|
||||||
|
command! GoOracleCallgraph
|
||||||
|
\ call s:RunOracle("callgraph")
|
||||||
|
|
||||||
|
" Describe the 'implements' relation for types in the
|
||||||
|
" package containing the current point.
|
||||||
|
command! GoOracleImplements
|
||||||
|
\ call s:RunOracle("implements")
|
||||||
|
|
||||||
|
" Enumerate the set of possible corresponding sends/receives for
|
||||||
|
" this channel receive/send operation.
|
||||||
|
command! GoOracleChannelPeers
|
||||||
|
\ call s:RunOracle("peers")
|
||||||
|
|
@ -0,0 +1,97 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"go/ast"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
"code.google.com/p/go.tools/pointer"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Callees reports the possible callees of the function call site
|
||||||
|
// identified by the specified source location.
|
||||||
|
//
|
||||||
|
// TODO(adonovan): if a callee is a wrapper, show the callee's callee.
|
||||||
|
//
|
||||||
|
func callees(o *oracle) (queryResult, error) {
|
||||||
|
// Determine the enclosing call for the specified position.
|
||||||
|
var call *ast.CallExpr
|
||||||
|
for _, n := range o.queryPath {
|
||||||
|
if call, _ = n.(*ast.CallExpr); call != nil {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if call == nil {
|
||||||
|
return nil, o.errorf(o.queryPath[0], "there is no function call here")
|
||||||
|
}
|
||||||
|
// TODO(adonovan): issue an error if the call is "too far
|
||||||
|
// away" from the current selection, as this most likely is
|
||||||
|
// not what the user intended.
|
||||||
|
|
||||||
|
// Reject type conversions.
|
||||||
|
if o.queryPkgInfo.IsType(call.Fun) {
|
||||||
|
return nil, o.errorf(call, "this is a type conversion, not a function call")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Reject calls to built-ins.
|
||||||
|
if b, ok := o.queryPkgInfo.TypeOf(call.Fun).(*types.Builtin); ok {
|
||||||
|
return nil, o.errorf(call, "this is a call to the built-in '%s' operator", b.Name())
|
||||||
|
}
|
||||||
|
|
||||||
|
buildSSA(o)
|
||||||
|
|
||||||
|
// Compute the subgraph of the callgraph for callsite(s)
|
||||||
|
// arising from 'call'. There may be more than one if its
|
||||||
|
// enclosing function was treated context-sensitively.
|
||||||
|
// (Or zero if it was in dead code.)
|
||||||
|
//
|
||||||
|
// The presence of a key indicates this call site is
|
||||||
|
// interesting even if the value is nil.
|
||||||
|
querySites := make(map[pointer.CallSite][]pointer.CallGraphNode)
|
||||||
|
o.config.CallSite = func(site pointer.CallSite) {
|
||||||
|
if site.Pos() == call.Lparen {
|
||||||
|
// Not a no-op! Ensures key is
|
||||||
|
// present even if value is nil:
|
||||||
|
querySites[site] = querySites[site]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
o.config.Call = func(site pointer.CallSite, caller, callee pointer.CallGraphNode) {
|
||||||
|
if targets, ok := querySites[site]; ok {
|
||||||
|
querySites[site] = append(targets, callee)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ptrAnalysis(o)
|
||||||
|
|
||||||
|
return &calleesResult{
|
||||||
|
call: call,
|
||||||
|
querySites: querySites,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type calleesResult struct {
|
||||||
|
call *ast.CallExpr
|
||||||
|
querySites map[pointer.CallSite][]pointer.CallGraphNode
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *calleesResult) display(o *oracle) {
|
||||||
|
// Print the set of discovered call edges.
|
||||||
|
if len(r.querySites) == 0 {
|
||||||
|
// e.g. it appears within "if false {...}" or within a dead function.
|
||||||
|
o.printf(r.call.Lparen, "this call site is unreachable in this analysis")
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO(adonovan): sort, to ensure test determinism.
|
||||||
|
// TODO(adonovan): compute union of callees across all contexts.
|
||||||
|
for site, callees := range r.querySites {
|
||||||
|
if callees == nil {
|
||||||
|
// dynamic call on a provably nil func/interface
|
||||||
|
o.printf(site, "%s on nil value", site.Description())
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO(adonovan): sort, to ensure test determinism.
|
||||||
|
o.printf(site, "this %s dispatches to:", site.Description())
|
||||||
|
for _, callee := range callees {
|
||||||
|
o.printf(callee.Func(), "\t%s", callee.Func())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,73 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"code.google.com/p/go.tools/pointer"
|
||||||
|
"code.google.com/p/go.tools/ssa"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Callers reports the possible callers of the function
|
||||||
|
// immediately enclosing the specified source location.
|
||||||
|
//
|
||||||
|
// TODO(adonovan): if a caller is a wrapper, show the caller's caller.
|
||||||
|
//
|
||||||
|
func callers(o *oracle) (queryResult, error) {
|
||||||
|
pkg := o.prog.Package(o.queryPkgInfo.Pkg)
|
||||||
|
if pkg == nil {
|
||||||
|
return nil, o.errorf(o.queryPath[0], "no SSA package")
|
||||||
|
}
|
||||||
|
if !ssa.HasEnclosingFunction(pkg, o.queryPath) {
|
||||||
|
return nil, o.errorf(o.queryPath[0], "this position is not inside a function")
|
||||||
|
}
|
||||||
|
|
||||||
|
buildSSA(o)
|
||||||
|
|
||||||
|
target := ssa.EnclosingFunction(pkg, o.queryPath)
|
||||||
|
if target == nil {
|
||||||
|
return nil, o.errorf(o.queryPath[0], "no SSA function built for this location (dead code?)")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Run the pointer analysis, recording each
|
||||||
|
// call found to originate from target.
|
||||||
|
var calls []callersCall
|
||||||
|
o.config.Call = func(site pointer.CallSite, caller, callee pointer.CallGraphNode) {
|
||||||
|
if callee.Func() == target {
|
||||||
|
calls = append(calls, callersCall{site, caller})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
root := ptrAnalysis(o)
|
||||||
|
|
||||||
|
return &callersResult{
|
||||||
|
target: target,
|
||||||
|
root: root,
|
||||||
|
calls: calls,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type callersResult struct {
|
||||||
|
target *ssa.Function
|
||||||
|
root pointer.CallGraphNode
|
||||||
|
calls []callersCall
|
||||||
|
}
|
||||||
|
|
||||||
|
type callersCall struct {
|
||||||
|
site pointer.CallSite
|
||||||
|
caller pointer.CallGraphNode
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *callersResult) display(o *oracle) {
|
||||||
|
if r.calls == nil {
|
||||||
|
o.printf(r.target, "%s is not reachable in this program.", r.target)
|
||||||
|
} else {
|
||||||
|
o.printf(r.target, "%s is called from these %d sites:", r.target, len(r.calls))
|
||||||
|
// TODO(adonovan): sort, to ensure test determinism.
|
||||||
|
for _, call := range r.calls {
|
||||||
|
if call.caller == r.root {
|
||||||
|
o.printf(r.target, "the root of the call graph")
|
||||||
|
} else {
|
||||||
|
o.printf(call.site, "\t%s from %s",
|
||||||
|
call.site.Description(), call.caller.Func())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,63 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"strings"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/pointer"
|
||||||
|
)
|
||||||
|
|
||||||
|
// callgraph displays the entire callgraph of the current program.
|
||||||
|
//
|
||||||
|
// Nodes may be seem to appear multiple times due to (limited)
|
||||||
|
// context sensitivity.
|
||||||
|
//
|
||||||
|
// TODO(adonovan): add options for restricting the display to a region
|
||||||
|
// of interest: function, package, subgraph, dirtree, etc.
|
||||||
|
//
|
||||||
|
func callgraph(o *oracle) (queryResult, error) {
|
||||||
|
buildSSA(o)
|
||||||
|
|
||||||
|
// Run the pointer analysis and build the complete callgraph.
|
||||||
|
callgraph := make(pointer.CallGraph)
|
||||||
|
o.config.Call = callgraph.AddEdge
|
||||||
|
root := ptrAnalysis(o)
|
||||||
|
|
||||||
|
return &callgraphResult{
|
||||||
|
root: root,
|
||||||
|
callgraph: callgraph,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type callgraphResult struct {
|
||||||
|
root pointer.CallGraphNode
|
||||||
|
callgraph pointer.CallGraph
|
||||||
|
|
||||||
|
numbering map[pointer.CallGraphNode]int // used by display
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *callgraphResult) print(o *oracle, cgn pointer.CallGraphNode, indent int) {
|
||||||
|
if n := r.numbering[cgn]; n == 0 {
|
||||||
|
n = 1 + len(r.numbering)
|
||||||
|
r.numbering[cgn] = n
|
||||||
|
o.printf(cgn.Func(), "%d\t%s%s", n, strings.Repeat(" ", indent), cgn.Func())
|
||||||
|
for callee := range r.callgraph[cgn] {
|
||||||
|
r.print(o, callee, indent+1)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
o.printf(cgn.Func(), "\t%s%s (%d)", strings.Repeat(" ", indent), cgn.Func(), n)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *callgraphResult) display(o *oracle) {
|
||||||
|
o.printf(nil, `
|
||||||
|
Below is a call graph of the entire program.
|
||||||
|
The numbered nodes form a spanning tree.
|
||||||
|
Non-numbered nodes indicate back- or cross-edges to the node whose
|
||||||
|
number follows in parentheses.
|
||||||
|
Some nodes may appear multiple times due to context-sensitive
|
||||||
|
treatment of some calls.
|
||||||
|
`)
|
||||||
|
|
||||||
|
r.numbering = make(map[pointer.CallGraphNode]int)
|
||||||
|
r.print(o, r.root, 0)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,86 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"code.google.com/p/go.tools/pointer"
|
||||||
|
"code.google.com/p/go.tools/ssa"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Callstack displays an arbitrary path from a root of the callgraph
|
||||||
|
// to the function at the current position.
|
||||||
|
//
|
||||||
|
// The information may be misleading in a context-insensitive
|
||||||
|
// analysis. e.g. the call path X->Y->Z might be infeasible if Y never
|
||||||
|
// calls Z when it is called from X. TODO(adonovan): think about UI.
|
||||||
|
//
|
||||||
|
// TODO(adonovan): permit user to specify a starting point other than
|
||||||
|
// the analysis root.
|
||||||
|
//
|
||||||
|
func callstack(o *oracle) (queryResult, error) {
|
||||||
|
pkg := o.prog.Package(o.queryPkgInfo.Pkg)
|
||||||
|
if pkg == nil {
|
||||||
|
return nil, o.errorf(o.queryPath[0], "no SSA package")
|
||||||
|
}
|
||||||
|
|
||||||
|
if !ssa.HasEnclosingFunction(pkg, o.queryPath) {
|
||||||
|
return nil, o.errorf(o.queryPath[0], "this position is not inside a function")
|
||||||
|
}
|
||||||
|
|
||||||
|
buildSSA(o)
|
||||||
|
|
||||||
|
target := ssa.EnclosingFunction(pkg, o.queryPath)
|
||||||
|
if target == nil {
|
||||||
|
return nil, o.errorf(o.queryPath[0],
|
||||||
|
"no SSA function built for this location (dead code?)")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Run the pointer analysis and build the complete call graph.
|
||||||
|
callgraph := make(pointer.CallGraph)
|
||||||
|
o.config.Call = callgraph.AddEdge
|
||||||
|
root := ptrAnalysis(o)
|
||||||
|
|
||||||
|
return &callstackResult{
|
||||||
|
target: target,
|
||||||
|
root: root,
|
||||||
|
callgraph: callgraph,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type callstackResult struct {
|
||||||
|
target *ssa.Function
|
||||||
|
root pointer.CallGraphNode
|
||||||
|
callgraph pointer.CallGraph
|
||||||
|
|
||||||
|
seen map[pointer.CallGraphNode]bool // used by display
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *callstackResult) search(o *oracle, cgn pointer.CallGraphNode) bool {
|
||||||
|
if !r.seen[cgn] {
|
||||||
|
r.seen[cgn] = true
|
||||||
|
if cgn.Func() == r.target {
|
||||||
|
o.printf(o, "Found a call path from root to %s", r.target)
|
||||||
|
o.printf(r.target, "%s", r.target)
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
for callee, site := range r.callgraph[cgn] {
|
||||||
|
if r.search(o, callee) {
|
||||||
|
o.printf(site, "%s from %s", site.Description(), cgn.Func())
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *callstackResult) display(o *oracle) {
|
||||||
|
// Show only an arbitrary path from a root to the current function.
|
||||||
|
// We use depth-first search.
|
||||||
|
|
||||||
|
r.seen = make(map[pointer.CallGraphNode]bool)
|
||||||
|
|
||||||
|
for toplevel := range r.callgraph[r.root] {
|
||||||
|
if r.search(o, toplevel) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
o.printf(r.target, "%s is unreachable in this analysis scope", r.target)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,715 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"fmt"
|
||||||
|
"go/ast"
|
||||||
|
"go/token"
|
||||||
|
"sort"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
"code.google.com/p/go.tools/importer"
|
||||||
|
"code.google.com/p/go.tools/pointer"
|
||||||
|
"code.google.com/p/go.tools/ssa"
|
||||||
|
)
|
||||||
|
|
||||||
|
// TODO(adonovan): all printed sets must be sorted to ensure test determinism.
|
||||||
|
|
||||||
|
// describe describes the syntax node denoted by the query position,
|
||||||
|
// including:
|
||||||
|
// - its syntactic category
|
||||||
|
// - the location of the definition of its referent (for identifiers)
|
||||||
|
// - its type and method set (for an expression or type expression)
|
||||||
|
// - its points-to set (for a pointer-like expression)
|
||||||
|
// - its concrete types (for an interface expression) and their points-to sets.
|
||||||
|
//
|
||||||
|
func describe(o *oracle) (queryResult, error) {
|
||||||
|
if false { // debugging
|
||||||
|
o.printf(o.queryPath[0], "you selected: %s %s",
|
||||||
|
importer.NodeDescription(o.queryPath[0]), pathToString2(o.queryPath))
|
||||||
|
}
|
||||||
|
|
||||||
|
path, action := findInterestingNode(o.queryPkgInfo, o.queryPath)
|
||||||
|
switch action {
|
||||||
|
case actionExpr:
|
||||||
|
return describeValue(o, path)
|
||||||
|
|
||||||
|
case actionType:
|
||||||
|
return describeType(o, path)
|
||||||
|
|
||||||
|
case actionPackage:
|
||||||
|
return describePackage(o, path)
|
||||||
|
|
||||||
|
case actionStmt:
|
||||||
|
return describeStmt(o, path)
|
||||||
|
|
||||||
|
case actionUnknown:
|
||||||
|
return &describeUnknownResult{path[0]}, nil
|
||||||
|
|
||||||
|
default:
|
||||||
|
panic(action) // unreachable
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
type describeUnknownResult struct {
|
||||||
|
node ast.Node
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *describeUnknownResult) display(o *oracle) {
|
||||||
|
// Nothing much to say about misc syntax.
|
||||||
|
o.printf(r.node, "%s", importer.NodeDescription(r.node))
|
||||||
|
}
|
||||||
|
|
||||||
|
type action int
|
||||||
|
|
||||||
|
const (
|
||||||
|
actionUnknown action = iota // None of the below
|
||||||
|
actionExpr // FuncDecl, true Expr or Ident(types.{Const,Var})
|
||||||
|
actionType // type Expr or Ident(types.TypeName).
|
||||||
|
actionStmt // Stmt or Ident(types.Label)
|
||||||
|
actionPackage // Ident(types.Package) or ImportSpec
|
||||||
|
)
|
||||||
|
|
||||||
|
// findInterestingNode classifies the syntax node denoted by path as one of:
|
||||||
|
// - an expression, part of an expression or a reference to a constant
|
||||||
|
// or variable;
|
||||||
|
// - a type, part of a type, or a reference to a named type;
|
||||||
|
// - a statement, part of a statement, or a label referring to a statement;
|
||||||
|
// - part of a package declaration or import spec.
|
||||||
|
// - none of the above.
|
||||||
|
// and returns the most "interesting" associated node, which may be
|
||||||
|
// the same node, an ancestor or a descendent.
|
||||||
|
//
|
||||||
|
func findInterestingNode(pkginfo *importer.PackageInfo, path []ast.Node) ([]ast.Node, action) {
|
||||||
|
// TODO(adonovan): integrate with go/types/stdlib_test.go and
|
||||||
|
// apply this to every AST node we can find to make sure it
|
||||||
|
// doesn't crash.
|
||||||
|
|
||||||
|
// TODO(adonovan): audit for ParenExpr safety, esp. since we
|
||||||
|
// traverse up and down.
|
||||||
|
|
||||||
|
// TODO(adonovan): if the users selects the "." in
|
||||||
|
// "fmt.Fprintf()", they'll get an ambiguous selection error;
|
||||||
|
// we won't even reach here. Can we do better?
|
||||||
|
|
||||||
|
// TODO(adonovan): describing a field within 'type T struct {...}'
|
||||||
|
// describes the (anonymous) struct type and concludes "no methods". Fix.
|
||||||
|
|
||||||
|
for len(path) > 0 {
|
||||||
|
switch n := path[0].(type) {
|
||||||
|
case *ast.GenDecl:
|
||||||
|
if len(n.Specs) == 1 {
|
||||||
|
// Descend to sole {Import,Type,Value}Spec child.
|
||||||
|
path = append([]ast.Node{n.Specs[0]}, path...)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
return path, actionUnknown // uninteresting
|
||||||
|
|
||||||
|
case *ast.FuncDecl:
|
||||||
|
// Descend to function name.
|
||||||
|
path = append([]ast.Node{n.Name}, path...)
|
||||||
|
continue
|
||||||
|
|
||||||
|
case *ast.ImportSpec:
|
||||||
|
return path, actionPackage
|
||||||
|
|
||||||
|
case *ast.ValueSpec:
|
||||||
|
if len(n.Names) == 1 {
|
||||||
|
// Descend to sole Ident child.
|
||||||
|
path = append([]ast.Node{n.Names[0]}, path...)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
return path, actionUnknown // uninteresting
|
||||||
|
|
||||||
|
case *ast.TypeSpec:
|
||||||
|
// Descend to type name.
|
||||||
|
path = append([]ast.Node{n.Name}, path...)
|
||||||
|
continue
|
||||||
|
|
||||||
|
case ast.Stmt:
|
||||||
|
return path, actionStmt
|
||||||
|
|
||||||
|
case *ast.ArrayType,
|
||||||
|
*ast.StructType,
|
||||||
|
*ast.FuncType,
|
||||||
|
*ast.InterfaceType,
|
||||||
|
*ast.MapType,
|
||||||
|
*ast.ChanType:
|
||||||
|
return path, actionType
|
||||||
|
|
||||||
|
case *ast.Comment, *ast.CommentGroup, *ast.File, *ast.KeyValueExpr, *ast.CommClause:
|
||||||
|
return path, actionUnknown // uninteresting
|
||||||
|
|
||||||
|
case *ast.Ellipsis:
|
||||||
|
// Continue to enclosing node.
|
||||||
|
// e.g. [...]T in ArrayType
|
||||||
|
// f(x...) in CallExpr
|
||||||
|
// f(x...T) in FuncType
|
||||||
|
|
||||||
|
case *ast.Field:
|
||||||
|
// TODO(adonovan): this needs more thought,
|
||||||
|
// since fields can be so many things.
|
||||||
|
if len(n.Names) == 1 {
|
||||||
|
// Descend to sole Ident child.
|
||||||
|
path = append([]ast.Node{n.Names[0]}, path...)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
// Zero names (e.g. anon field in struct)
|
||||||
|
// or multiple field or param names:
|
||||||
|
// continue to enclosing field list.
|
||||||
|
|
||||||
|
case *ast.FieldList:
|
||||||
|
// Continue to enclosing node:
|
||||||
|
// {Struct,Func,Interface}Type or FuncDecl.
|
||||||
|
|
||||||
|
case *ast.BasicLit:
|
||||||
|
if _, ok := path[1].(*ast.ImportSpec); ok {
|
||||||
|
return path[1:], actionPackage
|
||||||
|
}
|
||||||
|
return path, actionExpr
|
||||||
|
|
||||||
|
case *ast.SelectorExpr:
|
||||||
|
if pkginfo.ObjectOf(n.Sel) == nil {
|
||||||
|
// Is this reachable?
|
||||||
|
return path, actionUnknown
|
||||||
|
}
|
||||||
|
// Descend to .Sel child.
|
||||||
|
path = append([]ast.Node{n.Sel}, path...)
|
||||||
|
continue
|
||||||
|
|
||||||
|
case *ast.Ident:
|
||||||
|
switch obj := pkginfo.ObjectOf(n).(type) {
|
||||||
|
case *types.Package:
|
||||||
|
return path, actionPackage
|
||||||
|
|
||||||
|
case *types.Const:
|
||||||
|
return path, actionExpr
|
||||||
|
|
||||||
|
case *types.Label:
|
||||||
|
return path, actionStmt
|
||||||
|
|
||||||
|
case *types.TypeName:
|
||||||
|
return path, actionType
|
||||||
|
|
||||||
|
case *types.Var:
|
||||||
|
// For x in 'struct {x T}', return struct type, for now.
|
||||||
|
if _, ok := path[1].(*ast.Field); ok {
|
||||||
|
_ = path[2].(*ast.FieldList) // assertion
|
||||||
|
if _, ok := path[3].(*ast.StructType); ok {
|
||||||
|
return path[3:], actionType
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return path, actionExpr
|
||||||
|
|
||||||
|
case *types.Func:
|
||||||
|
// For f in 'interface {f()}', return the interface type, for now.
|
||||||
|
if _, ok := path[1].(*ast.Field); ok {
|
||||||
|
_ = path[2].(*ast.FieldList) // assertion
|
||||||
|
if _, ok := path[3].(*ast.InterfaceType); ok {
|
||||||
|
return path[3:], actionType
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// For reference to built-in function, return enclosing call.
|
||||||
|
if _, ok := obj.Type().(*types.Builtin); ok {
|
||||||
|
// Ascend to enclosing function call.
|
||||||
|
path = path[1:]
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
return path, actionExpr
|
||||||
|
}
|
||||||
|
|
||||||
|
// No object.
|
||||||
|
switch path[1].(type) {
|
||||||
|
case *ast.SelectorExpr:
|
||||||
|
// Return enclosing selector expression.
|
||||||
|
return path[1:], actionExpr
|
||||||
|
|
||||||
|
case *ast.Field:
|
||||||
|
// TODO(adonovan): test this.
|
||||||
|
// e.g. all f in:
|
||||||
|
// struct { f, g int }
|
||||||
|
// interface { f() }
|
||||||
|
// func (f T) method(f, g int) (f, g bool)
|
||||||
|
//
|
||||||
|
// switch path[3].(type) {
|
||||||
|
// case *ast.FuncDecl:
|
||||||
|
// case *ast.StructType:
|
||||||
|
// case *ast.InterfaceType:
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// return path[1:], actionExpr
|
||||||
|
//
|
||||||
|
// Unclear what to do with these.
|
||||||
|
// Struct.Fields -- field
|
||||||
|
// Interface.Methods -- field
|
||||||
|
// FuncType.{Params.Results} -- actionExpr
|
||||||
|
// FuncDecl.Recv -- actionExpr
|
||||||
|
|
||||||
|
case *ast.ImportSpec:
|
||||||
|
// TODO(adonovan): fix: why no package object? go/types bug?
|
||||||
|
return path[1:], actionPackage
|
||||||
|
|
||||||
|
default:
|
||||||
|
// e.g. blank identifier (go/types bug?)
|
||||||
|
// or y in "switch y := x.(type)" (go/types bug?)
|
||||||
|
fmt.Printf("unknown reference %s in %T\n", n, path[1])
|
||||||
|
return path, actionUnknown
|
||||||
|
}
|
||||||
|
|
||||||
|
case *ast.StarExpr:
|
||||||
|
if pkginfo.IsType(n) {
|
||||||
|
return path, actionType
|
||||||
|
}
|
||||||
|
return path, actionExpr
|
||||||
|
|
||||||
|
case ast.Expr:
|
||||||
|
// All Expr but {BasicLit,Ident,StarExpr} are
|
||||||
|
// "true" expressions that evaluate to a value.
|
||||||
|
return path, actionExpr
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ascend to parent.
|
||||||
|
path = path[1:]
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil, actionUnknown // unreachable
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- VALUE ------------------------------------------------------------
|
||||||
|
|
||||||
|
// ssaValueForIdent returns the ssa.Value for the ast.Ident whose path
|
||||||
|
// to the root of the AST is path. It may return a nil Value without
|
||||||
|
// an error to indicate the pointer analysis is not appropriate.
|
||||||
|
//
|
||||||
|
func ssaValueForIdent(o *oracle, obj types.Object, path []ast.Node) (ssa.Value, error) {
|
||||||
|
if obj, ok := obj.(*types.Var); ok {
|
||||||
|
pkg := o.prog.Package(o.queryPkgInfo.Pkg)
|
||||||
|
pkg.Build()
|
||||||
|
if v := o.prog.VarValue(obj, pkg, path); v != nil {
|
||||||
|
// Don't run pointer analysis on a ref to a const expression.
|
||||||
|
if _, ok := v.(*ssa.Const); ok {
|
||||||
|
v = nil
|
||||||
|
}
|
||||||
|
return v, nil
|
||||||
|
}
|
||||||
|
return nil, fmt.Errorf("can't locate SSA Value for var %s", obj.Name())
|
||||||
|
}
|
||||||
|
|
||||||
|
// Don't run pointer analysis on const/func objects.
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// ssaValueForExpr returns the ssa.Value of the non-ast.Ident
|
||||||
|
// expression whose path to the root of the AST is path. It may
|
||||||
|
// return a nil Value without an error to indicate the pointer
|
||||||
|
// analysis is not appropriate.
|
||||||
|
//
|
||||||
|
func ssaValueForExpr(o *oracle, path []ast.Node) (ssa.Value, error) {
|
||||||
|
pkg := o.prog.Package(o.queryPkgInfo.Pkg)
|
||||||
|
pkg.SetDebugMode(true)
|
||||||
|
pkg.Build()
|
||||||
|
|
||||||
|
fn := ssa.EnclosingFunction(pkg, path)
|
||||||
|
if fn == nil {
|
||||||
|
return nil, fmt.Errorf("no SSA function built for this location (dead code?)")
|
||||||
|
}
|
||||||
|
|
||||||
|
if v := fn.ValueForExpr(path[0].(ast.Expr)); v != nil {
|
||||||
|
return v, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil, fmt.Errorf("can't locate SSA Value for expression in %s", fn)
|
||||||
|
}
|
||||||
|
|
||||||
|
func describeValue(o *oracle, path []ast.Node) (*describeValueResult, error) {
|
||||||
|
var expr ast.Expr
|
||||||
|
switch n := path[0].(type) {
|
||||||
|
case *ast.ValueSpec:
|
||||||
|
// ambiguous ValueSpec containing multiple names
|
||||||
|
return nil, o.errorf(n, "multiple value specification")
|
||||||
|
case ast.Expr:
|
||||||
|
expr = n
|
||||||
|
default:
|
||||||
|
// Is this reachable?
|
||||||
|
return nil, o.errorf(n, "unexpected AST for expr: %T", n)
|
||||||
|
}
|
||||||
|
|
||||||
|
// From this point on, we cannot fail with an error.
|
||||||
|
// Failure to run the pointer analysis will be reported later.
|
||||||
|
|
||||||
|
var value ssa.Value
|
||||||
|
var ptaErr error
|
||||||
|
var obj types.Object
|
||||||
|
|
||||||
|
// Determine the ssa.Value for the expression.
|
||||||
|
if id, ok := expr.(*ast.Ident); ok {
|
||||||
|
// def/ref of func/var/const object
|
||||||
|
obj = o.queryPkgInfo.ObjectOf(id)
|
||||||
|
value, ptaErr = ssaValueForIdent(o, obj, path)
|
||||||
|
} else {
|
||||||
|
// any other expression
|
||||||
|
if o.queryPkgInfo.ValueOf(expr) == nil { // non-constant?
|
||||||
|
value, ptaErr = ssaValueForExpr(o, path)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Don't run pointer analysis on non-pointerlike types.
|
||||||
|
if value != nil && !pointer.CanPoint(value.Type()) {
|
||||||
|
value = nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Run pointer analysis of the selected SSA value.
|
||||||
|
var ptrs []pointer.Pointer
|
||||||
|
if value != nil {
|
||||||
|
buildSSA(o)
|
||||||
|
|
||||||
|
o.config.QueryValues = map[ssa.Value][]pointer.Pointer{value: nil}
|
||||||
|
ptrAnalysis(o)
|
||||||
|
ptrs = o.config.QueryValues[value]
|
||||||
|
}
|
||||||
|
|
||||||
|
return &describeValueResult{
|
||||||
|
expr: expr,
|
||||||
|
obj: obj,
|
||||||
|
value: value,
|
||||||
|
ptaErr: ptaErr,
|
||||||
|
ptrs: ptrs,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type describeValueResult struct {
|
||||||
|
expr ast.Expr // query node
|
||||||
|
obj types.Object // var/func/const object, if expr was Ident
|
||||||
|
value ssa.Value // ssa.Value for pointer analysis query
|
||||||
|
ptaErr error // explanation of why we couldn't run pointer analysis
|
||||||
|
ptrs []pointer.Pointer // result of pointer analysis query
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *describeValueResult) display(o *oracle) {
|
||||||
|
suffix := ""
|
||||||
|
if val := o.queryPkgInfo.ValueOf(r.expr); val != nil {
|
||||||
|
suffix = fmt.Sprintf(" of constant value %s", val)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Describe the expression.
|
||||||
|
if r.obj != nil {
|
||||||
|
if r.obj.Pos() == r.expr.Pos() {
|
||||||
|
// defining ident
|
||||||
|
o.printf(r.expr, "definition of %s%s", r.obj, suffix)
|
||||||
|
} else {
|
||||||
|
// referring ident
|
||||||
|
o.printf(r.expr, "reference to %s%s", r.obj, suffix)
|
||||||
|
if def := r.obj.Pos(); def != token.NoPos {
|
||||||
|
o.printf(def, "defined here")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
desc := importer.NodeDescription(r.expr)
|
||||||
|
if suffix != "" {
|
||||||
|
// constant expression
|
||||||
|
o.printf(r.expr, "%s%s", desc, suffix)
|
||||||
|
} else {
|
||||||
|
// non-constant expression
|
||||||
|
o.printf(r.expr, "%s of type %s", desc, o.queryPkgInfo.TypeOf(r.expr))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if r.value == nil {
|
||||||
|
// pointer analysis was not run
|
||||||
|
if r.ptaErr != nil {
|
||||||
|
o.printf(r.expr, "no pointer analysis: %s", r.ptaErr)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if r.ptrs == nil {
|
||||||
|
o.printf(r.expr, "pointer analysis did not analyze this expression (dead code?)")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Display the results of pointer analysis.
|
||||||
|
|
||||||
|
// Combine the PT sets from all contexts.
|
||||||
|
pts := pointer.PointsToCombined(r.ptrs)
|
||||||
|
|
||||||
|
// Report which make(chan) labels the query's channel can alias.
|
||||||
|
if _, ok := r.value.Type().Underlying().(*types.Interface); ok {
|
||||||
|
// Show concrete types for interface expression.
|
||||||
|
if concs := pts.ConcreteTypes(); concs.Len() > 0 {
|
||||||
|
o.printf(o, "interface may contain these concrete types:")
|
||||||
|
// TODO(adonovan): must sort to ensure deterministic test behaviour.
|
||||||
|
concs.Iterate(func(conc types.Type, ptrs interface{}) {
|
||||||
|
var obj types.Object
|
||||||
|
if nt, ok := deref(conc).(*types.Named); ok {
|
||||||
|
obj = nt.Obj()
|
||||||
|
}
|
||||||
|
|
||||||
|
pts := pointer.PointsToCombined(ptrs.([]pointer.Pointer))
|
||||||
|
if labels := pts.Labels(); len(labels) > 0 {
|
||||||
|
o.printf(obj, "\t%s, may point to:", conc)
|
||||||
|
printLabels(o, labels, "\t\t")
|
||||||
|
} else {
|
||||||
|
o.printf(obj, "\t%s", conc)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
} else {
|
||||||
|
o.printf(o, "interface cannot contain any concrete values.")
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Show labels for other expressions.
|
||||||
|
if labels := pts.Labels(); len(labels) > 0 {
|
||||||
|
o.printf(o, "value may point to these labels:")
|
||||||
|
printLabels(o, labels, "\t")
|
||||||
|
} else {
|
||||||
|
o.printf(o, "value cannot point to anything.")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
type byPosAndString []*pointer.Label
|
||||||
|
|
||||||
|
func (a byPosAndString) Len() int { return len(a) }
|
||||||
|
func (a byPosAndString) Less(i, j int) bool {
|
||||||
|
cmp := a[i].Pos() - a[j].Pos()
|
||||||
|
return cmp < 0 || (cmp == 0 && a[i].String() < a[j].String())
|
||||||
|
}
|
||||||
|
func (a byPosAndString) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
|
||||||
|
|
||||||
|
func printLabels(o *oracle, labels []*pointer.Label, prefix string) {
|
||||||
|
// Sort, to ensure deterministic test behaviour.
|
||||||
|
sort.Sort(byPosAndString(labels))
|
||||||
|
// TODO(adonovan): due to context-sensitivity, many of these
|
||||||
|
// labels may differ only by context, which isn't apparent.
|
||||||
|
for _, label := range labels {
|
||||||
|
o.printf(label, "%s%s", prefix, label)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- TYPE ------------------------------------------------------------
|
||||||
|
|
||||||
|
func describeType(o *oracle, path []ast.Node) (*describeTypeResult, error) {
|
||||||
|
var description string
|
||||||
|
var t types.Type
|
||||||
|
switch n := path[0].(type) {
|
||||||
|
case *ast.Ident:
|
||||||
|
t = o.queryPkgInfo.TypeOf(n)
|
||||||
|
switch t := t.(type) {
|
||||||
|
case *types.Basic:
|
||||||
|
description = "reference to built-in type " + t.String()
|
||||||
|
|
||||||
|
case *types.Named:
|
||||||
|
isDef := t.Obj().Pos() == n.Pos() // see caveats at isDef above
|
||||||
|
if isDef {
|
||||||
|
description = "definition of type " + t.String()
|
||||||
|
} else {
|
||||||
|
description = "reference to type " + t.String()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
case ast.Expr:
|
||||||
|
t = o.queryPkgInfo.TypeOf(n)
|
||||||
|
description = "type " + t.String()
|
||||||
|
|
||||||
|
default:
|
||||||
|
// Unreachable?
|
||||||
|
return nil, o.errorf(n, "unexpected AST for type: %T", n)
|
||||||
|
}
|
||||||
|
|
||||||
|
return &describeTypeResult{path[0], description, t}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type describeTypeResult struct {
|
||||||
|
node ast.Node
|
||||||
|
description string
|
||||||
|
typ types.Type
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *describeTypeResult) display(o *oracle) {
|
||||||
|
o.printf(r.node, "%s", r.description)
|
||||||
|
|
||||||
|
// Show the underlying type for a reference to a named type.
|
||||||
|
if nt, ok := r.typ.(*types.Named); ok && r.node.Pos() != nt.Obj().Pos() {
|
||||||
|
o.printf(nt.Obj(), "defined as %s", nt.Underlying())
|
||||||
|
}
|
||||||
|
|
||||||
|
// Print the method set, if the type kind is capable of bearing methods.
|
||||||
|
switch r.typ.(type) {
|
||||||
|
case *types.Interface, *types.Struct, *types.Named:
|
||||||
|
// TODO(adonovan): don't show unexported methods if
|
||||||
|
// r.typ belongs to a package other than the query
|
||||||
|
// package.
|
||||||
|
if m := ssa.IntuitiveMethodSet(r.typ); m != nil {
|
||||||
|
o.printf(r.node, "Method set:")
|
||||||
|
for _, meth := range m {
|
||||||
|
o.printf(meth.Obj(), "\t%s", meth)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
o.printf(r.node, "No methods.")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- PACKAGE ------------------------------------------------------------
|
||||||
|
|
||||||
|
func describePackage(o *oracle, path []ast.Node) (*describePackageResult, error) {
|
||||||
|
var description string
|
||||||
|
var importPath string
|
||||||
|
switch n := path[0].(type) {
|
||||||
|
case *ast.ImportSpec:
|
||||||
|
// importPath = o.queryPkgInfo.ObjectOf(n.Name).(*types.Package).Path()
|
||||||
|
// description = "import of package " + importPath
|
||||||
|
// TODO(gri): o.queryPkgInfo.ObjectOf(n.Name) may be nil.
|
||||||
|
// e.g. "fmt" import in cmd/oracle/main.go. Why?
|
||||||
|
// Workaround:
|
||||||
|
description = "import of package " + n.Path.Value
|
||||||
|
importPath, _ = strconv.Unquote(n.Path.Value)
|
||||||
|
|
||||||
|
case *ast.Ident:
|
||||||
|
importPath = o.queryPkgInfo.ObjectOf(n).(*types.Package).Path()
|
||||||
|
if _, isDef := path[1].(*ast.File); isDef {
|
||||||
|
description = fmt.Sprintf("definition of package %q", importPath)
|
||||||
|
} else {
|
||||||
|
description = fmt.Sprintf("reference to package %q", importPath)
|
||||||
|
}
|
||||||
|
if importPath == "" {
|
||||||
|
// TODO(gri): fix.
|
||||||
|
return nil, o.errorf(n, "types.Package.Path() returned \"\"\n")
|
||||||
|
}
|
||||||
|
|
||||||
|
default:
|
||||||
|
// Unreachable?
|
||||||
|
return nil, o.errorf(n, "unexpected AST for package: %T", n)
|
||||||
|
}
|
||||||
|
|
||||||
|
pkg := o.prog.PackagesByPath[importPath]
|
||||||
|
|
||||||
|
return &describePackageResult{path[0], description, pkg}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type describePackageResult struct {
|
||||||
|
node ast.Node
|
||||||
|
description string
|
||||||
|
pkg *ssa.Package
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *describePackageResult) display(o *oracle) {
|
||||||
|
o.printf(r.node, "%s", r.description)
|
||||||
|
// TODO(adonovan): factor this into a testable utility function.
|
||||||
|
if p := r.pkg; p != nil {
|
||||||
|
samePkg := p.Object == o.queryPkgInfo.Pkg
|
||||||
|
|
||||||
|
// Describe exported package members, in lexicographic order.
|
||||||
|
|
||||||
|
// Compute max width of name "column".
|
||||||
|
var names []string
|
||||||
|
maxname := 0
|
||||||
|
for name := range p.Members {
|
||||||
|
if samePkg || ast.IsExported(name) {
|
||||||
|
if l := len(name); l > maxname {
|
||||||
|
maxname = l
|
||||||
|
}
|
||||||
|
names = append(names, name)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
sort.Strings(names)
|
||||||
|
|
||||||
|
// Print the members.
|
||||||
|
for _, name := range names {
|
||||||
|
mem := p.Members[name]
|
||||||
|
o.printf(mem, "%s", formatMember(mem, maxname))
|
||||||
|
// Print method set.
|
||||||
|
if mem, ok := mem.(*ssa.Type); ok {
|
||||||
|
for _, meth := range ssa.IntuitiveMethodSet(mem.Type()) {
|
||||||
|
if samePkg || ast.IsExported(meth.Obj().Name()) {
|
||||||
|
o.printf(meth.Obj(), "\t\t%s", meth)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func formatMember(mem ssa.Member, maxname int) string {
|
||||||
|
var buf bytes.Buffer
|
||||||
|
fmt.Fprintf(&buf, "\t%-5s %-*s", mem.Token(), maxname, mem.Name())
|
||||||
|
switch mem := mem.(type) {
|
||||||
|
case *ssa.NamedConst:
|
||||||
|
fmt.Fprintf(&buf, " %s = %s", mem.Type(), mem.Value.Name())
|
||||||
|
|
||||||
|
case *ssa.Function:
|
||||||
|
fmt.Fprintf(&buf, " %s", mem.Type())
|
||||||
|
|
||||||
|
case *ssa.Type:
|
||||||
|
// Abbreviate long aggregate type names.
|
||||||
|
var abbrev string
|
||||||
|
switch t := mem.Type().Underlying().(type) {
|
||||||
|
case *types.Interface:
|
||||||
|
if t.NumMethods() > 1 {
|
||||||
|
abbrev = "interface{...}"
|
||||||
|
}
|
||||||
|
case *types.Struct:
|
||||||
|
if t.NumFields() > 1 {
|
||||||
|
abbrev = "struct{...}"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if abbrev == "" {
|
||||||
|
fmt.Fprintf(&buf, " %s", mem.Type().Underlying())
|
||||||
|
} else {
|
||||||
|
fmt.Fprintf(&buf, " %s", abbrev)
|
||||||
|
}
|
||||||
|
|
||||||
|
case *ssa.Global:
|
||||||
|
fmt.Fprintf(&buf, " %s", deref(mem.Type()))
|
||||||
|
}
|
||||||
|
return buf.String()
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---- STATEMENT ------------------------------------------------------------
|
||||||
|
|
||||||
|
func describeStmt(o *oracle, path []ast.Node) (*describeStmtResult, error) {
|
||||||
|
var description string
|
||||||
|
switch n := path[0].(type) {
|
||||||
|
case *ast.Ident:
|
||||||
|
if o.queryPkgInfo.ObjectOf(n).Pos() == n.Pos() {
|
||||||
|
description = "labelled statement"
|
||||||
|
} else {
|
||||||
|
description = "reference to labelled statement"
|
||||||
|
}
|
||||||
|
|
||||||
|
default:
|
||||||
|
// Nothing much to say about statements.
|
||||||
|
description = importer.NodeDescription(n)
|
||||||
|
}
|
||||||
|
return &describeStmtResult{path[0], description}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type describeStmtResult struct {
|
||||||
|
node ast.Node
|
||||||
|
description string
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *describeStmtResult) display(o *oracle) {
|
||||||
|
o.printf(r.node, "%s", r.description)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ------------------- Utilities -------------------
|
||||||
|
|
||||||
|
// pathToString returns a string containing the concrete types of the
|
||||||
|
// nodes in path.
|
||||||
|
func pathToString2(path []ast.Node) string {
|
||||||
|
var buf bytes.Buffer
|
||||||
|
fmt.Fprint(&buf, "[")
|
||||||
|
for i, n := range path {
|
||||||
|
if i > 0 {
|
||||||
|
fmt.Fprint(&buf, " ")
|
||||||
|
}
|
||||||
|
fmt.Fprint(&buf, strings.TrimPrefix(fmt.Sprintf("%T", n), "*ast."))
|
||||||
|
}
|
||||||
|
fmt.Fprint(&buf, "]")
|
||||||
|
return buf.String()
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,143 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"go/ast"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
)
|
||||||
|
|
||||||
|
// freevars displays the lexical (not package-level) free variables of
|
||||||
|
// the selection.
|
||||||
|
//
|
||||||
|
// It treats A.B.C as a separate variable from A to reveal the parts
|
||||||
|
// of an aggregate type that are actually needed.
|
||||||
|
// This aids refactoring.
|
||||||
|
//
|
||||||
|
// TODO(adonovan): optionally display the free references to
|
||||||
|
// file/package scope objects, and to objects from other packages.
|
||||||
|
// Depending on where the resulting function abstraction will go,
|
||||||
|
// these might be interesting. Perhaps group the results into three
|
||||||
|
// bands.
|
||||||
|
//
|
||||||
|
func freevars(o *oracle) (queryResult, error) {
|
||||||
|
file := o.queryPath[len(o.queryPath)-1] // the enclosing file
|
||||||
|
|
||||||
|
// The id and sel functions return non-nil if they denote an
|
||||||
|
// object o or selection o.x.y that is referenced by the
|
||||||
|
// selection but defined neither within the selection nor at
|
||||||
|
// file scope, i.e. it is in the lexical environment.
|
||||||
|
var id func(n *ast.Ident) types.Object
|
||||||
|
var sel func(n *ast.SelectorExpr) types.Object
|
||||||
|
|
||||||
|
sel = func(n *ast.SelectorExpr) types.Object {
|
||||||
|
switch x := unparen(n.X).(type) {
|
||||||
|
case *ast.SelectorExpr:
|
||||||
|
return sel(x)
|
||||||
|
case *ast.Ident:
|
||||||
|
return id(x)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
id = func(n *ast.Ident) types.Object {
|
||||||
|
obj := o.queryPkgInfo.ObjectOf(n)
|
||||||
|
if obj == nil {
|
||||||
|
return nil // TODO(adonovan): fix: this fails for *types.Label.
|
||||||
|
panic(o.errorf(n, "no types.Object for ast.Ident"))
|
||||||
|
}
|
||||||
|
if _, ok := obj.(*types.Package); ok {
|
||||||
|
return nil // imported package
|
||||||
|
}
|
||||||
|
if n.Pos() == obj.Pos() {
|
||||||
|
return nil // this ident is the definition, not a reference
|
||||||
|
}
|
||||||
|
if !(file.Pos() <= obj.Pos() && obj.Pos() <= file.End()) {
|
||||||
|
return nil // not defined in this file
|
||||||
|
}
|
||||||
|
if obj.Parent() == nil {
|
||||||
|
return nil // e.g. interface method TODO(adonovan): what else?
|
||||||
|
}
|
||||||
|
if obj.Parent() == o.queryPkgInfo.Scopes[file] {
|
||||||
|
return nil // defined at file scope
|
||||||
|
}
|
||||||
|
if o.startPos <= obj.Pos() && obj.Pos() <= o.endPos {
|
||||||
|
return nil // defined within selection => not free
|
||||||
|
}
|
||||||
|
return obj
|
||||||
|
}
|
||||||
|
|
||||||
|
// Maps each reference that is free in the selection
|
||||||
|
// to the object it refers to.
|
||||||
|
freeRefs := make(map[string]freevarsRef)
|
||||||
|
|
||||||
|
// Visit all the identifiers in the selected ASTs.
|
||||||
|
ast.Inspect(o.queryPath[0], func(n ast.Node) bool {
|
||||||
|
if n == nil {
|
||||||
|
return true // popping DFS stack
|
||||||
|
}
|
||||||
|
|
||||||
|
// Is this node contained within the selection?
|
||||||
|
// (freevars permits inexact selections,
|
||||||
|
// like two stmts in a block.)
|
||||||
|
if o.startPos <= n.Pos() && n.End() <= o.endPos {
|
||||||
|
switch n := n.(type) {
|
||||||
|
case *ast.Ident:
|
||||||
|
if obj := id(n); obj != nil {
|
||||||
|
freeRefs[o.printNode(n)] = freevarsRef{n, obj}
|
||||||
|
}
|
||||||
|
|
||||||
|
case *ast.SelectorExpr:
|
||||||
|
if obj := sel(n); obj != nil {
|
||||||
|
freeRefs[o.printNode(n)] = freevarsRef{n, obj}
|
||||||
|
return false // don't descend
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true // descend
|
||||||
|
})
|
||||||
|
|
||||||
|
return &freevarsResult{
|
||||||
|
refs: freeRefs,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type freevarsResult struct {
|
||||||
|
refs map[string]freevarsRef
|
||||||
|
}
|
||||||
|
|
||||||
|
type freevarsRef struct {
|
||||||
|
expr ast.Expr
|
||||||
|
obj types.Object
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *freevarsResult) display(o *oracle) {
|
||||||
|
if len(r.refs) == 0 {
|
||||||
|
o.printf(o, "No free identifers.")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
o.printf(o, "Free identifers:")
|
||||||
|
for s, ref := range r.refs {
|
||||||
|
typ := ref.obj.Type()
|
||||||
|
if _, ok := ref.expr.(*ast.SelectorExpr); ok {
|
||||||
|
typ = o.queryPkgInfo.TypeOf(ref.expr)
|
||||||
|
}
|
||||||
|
var kind string
|
||||||
|
switch ref.obj.(type) {
|
||||||
|
case *types.Var:
|
||||||
|
kind = "var"
|
||||||
|
case *types.Func:
|
||||||
|
kind = "func"
|
||||||
|
case *types.TypeName:
|
||||||
|
kind = "type"
|
||||||
|
case *types.Const:
|
||||||
|
kind = "const"
|
||||||
|
case *types.Label:
|
||||||
|
kind = "label"
|
||||||
|
default:
|
||||||
|
panic(ref.obj)
|
||||||
|
}
|
||||||
|
o.printf(ref.obj, "%s %s %s", kind, s, typ)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,84 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
"code.google.com/p/go.tools/ssa"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Implements displays the 'implements" relation among all
|
||||||
|
// package-level named types in the package containing the query
|
||||||
|
// position.
|
||||||
|
//
|
||||||
|
// TODO(adonovan): more features:
|
||||||
|
// - should we include pairs of types belonging to
|
||||||
|
// different packages in the 'implements' relation?//
|
||||||
|
// - should we restrict the query to the type declaration identified
|
||||||
|
// by the query position, if any, and use all types in the package
|
||||||
|
// otherwise?
|
||||||
|
// - should we show types that are local to functions?
|
||||||
|
// They can only have methods via promotion.
|
||||||
|
// - abbreviate the set of concrete types implementing the empty
|
||||||
|
// interface.
|
||||||
|
// - should we scan the instruction stream for MakeInterface
|
||||||
|
// instructions and report which concrete->interface conversions
|
||||||
|
// actually occur, with examples? (NB: this is not a conservative
|
||||||
|
// answer due to ChangeInterface, i.e. subtyping among interfaces.)
|
||||||
|
//
|
||||||
|
func implements(o *oracle) (queryResult, error) {
|
||||||
|
pkg := o.prog.Package(o.queryPkgInfo.Pkg)
|
||||||
|
if pkg == nil {
|
||||||
|
return nil, o.errorf(o.queryPath[0], "no SSA package")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compute set of named interface/concrete types at package level.
|
||||||
|
var interfaces, concretes []*types.Named
|
||||||
|
for _, mem := range pkg.Members {
|
||||||
|
if t, ok := mem.(*ssa.Type); ok {
|
||||||
|
nt := t.Type().(*types.Named)
|
||||||
|
if _, ok := nt.Underlying().(*types.Interface); ok {
|
||||||
|
interfaces = append(interfaces, nt)
|
||||||
|
} else {
|
||||||
|
concretes = append(concretes, nt)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// For each interface, show the concrete types that implement it.
|
||||||
|
var facts []implementsFact
|
||||||
|
for _, iface := range interfaces {
|
||||||
|
fact := implementsFact{iface: iface}
|
||||||
|
for _, conc := range concretes {
|
||||||
|
if types.IsAssignableTo(conc, iface) {
|
||||||
|
fact.conc = conc
|
||||||
|
} else if ptr := types.NewPointer(conc); types.IsAssignableTo(ptr, iface) {
|
||||||
|
fact.conc = ptr
|
||||||
|
} else {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
facts = append(facts, fact)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return &implementsResult{facts}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type implementsFact struct {
|
||||||
|
iface *types.Named
|
||||||
|
conc types.Type // Named or Pointer(Named)
|
||||||
|
}
|
||||||
|
|
||||||
|
type implementsResult struct {
|
||||||
|
facts []implementsFact // facts are grouped by interface
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *implementsResult) display(o *oracle) {
|
||||||
|
// TODO(adonovan): sort to ensure test nondeterminism.
|
||||||
|
var prevIface *types.Named
|
||||||
|
for _, fact := range r.facts {
|
||||||
|
if fact.iface != prevIface {
|
||||||
|
o.printf(fact.iface.Obj(), "\tInterface %s:", fact.iface)
|
||||||
|
prevIface = fact.iface
|
||||||
|
}
|
||||||
|
o.printf(deref(fact.conc).(*types.Named).Obj(), "\t\t%s", fact.conc)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,381 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
// This file defines oracle.Main, the entry point for the oracle tool.
|
||||||
|
// The actual executable is defined in cmd/oracle.
|
||||||
|
|
||||||
|
// TODO(adonovan): new query: show all statements that may update the
|
||||||
|
// selected lvalue (local, global, field, etc).
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"go/ast"
|
||||||
|
"go/build"
|
||||||
|
"go/printer"
|
||||||
|
"go/token"
|
||||||
|
"io"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
"code.google.com/p/go.tools/importer"
|
||||||
|
"code.google.com/p/go.tools/pointer"
|
||||||
|
"code.google.com/p/go.tools/ssa"
|
||||||
|
)
|
||||||
|
|
||||||
|
type oracle struct {
|
||||||
|
out io.Writer // standard output
|
||||||
|
prog *ssa.Program // the SSA program [need&SSA]
|
||||||
|
config pointer.Config // pointer analysis configuration
|
||||||
|
|
||||||
|
// need&(Pos|ExactPos):
|
||||||
|
startPos, endPos token.Pos // source extent of query
|
||||||
|
queryPkgInfo *importer.PackageInfo // type info for the queried package
|
||||||
|
queryPath []ast.Node // AST path from query node to root of ast.File
|
||||||
|
|
||||||
|
timers map[string]time.Duration // phase timing information
|
||||||
|
}
|
||||||
|
|
||||||
|
// A set of bits indicating the analytical requirements of each mode.
|
||||||
|
const (
|
||||||
|
Pos = 1 << iota // needs a position
|
||||||
|
ExactPos // needs an exact AST selection; implies Pos
|
||||||
|
SSA // needs SSA intermediate form
|
||||||
|
WholeSource // needs ASTs/SSA (not just types) for whole program
|
||||||
|
|
||||||
|
// TODO(adonovan): implement more efficiently than WholeSource|SSA.
|
||||||
|
TypedAST = WholeSource | SSA // needs typed AST for the queried package; implies Pos
|
||||||
|
)
|
||||||
|
|
||||||
|
type modeInfo struct {
|
||||||
|
needs int
|
||||||
|
impl func(*oracle) (queryResult, error)
|
||||||
|
}
|
||||||
|
|
||||||
|
var modes = map[string]modeInfo{
|
||||||
|
"callees": modeInfo{WholeSource | SSA | ExactPos, callees},
|
||||||
|
"callers": modeInfo{WholeSource | SSA | Pos, callers},
|
||||||
|
"callgraph": modeInfo{WholeSource | SSA, callgraph},
|
||||||
|
"callstack": modeInfo{WholeSource | SSA | Pos, callstack},
|
||||||
|
"describe": modeInfo{WholeSource | SSA | ExactPos, describe},
|
||||||
|
"freevars": modeInfo{TypedAST | Pos, freevars},
|
||||||
|
"implements": modeInfo{TypedAST | Pos, implements},
|
||||||
|
"peers": modeInfo{WholeSource | SSA | Pos, peers},
|
||||||
|
}
|
||||||
|
|
||||||
|
type queryResult interface {
|
||||||
|
display(o *oracle)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Main runs the oracle.
|
||||||
|
// args specify the main package in importer.CreatePackageFromArgs syntax.
|
||||||
|
// mode is the query mode ("callers", etc).
|
||||||
|
// pos is the selection in parseQueryPos() syntax.
|
||||||
|
// ptalog is the (optional) pointer-analysis log file.
|
||||||
|
// out is the standard output stream.
|
||||||
|
// buildContext is the optional configuration for locating packages.
|
||||||
|
//
|
||||||
|
func Main(args []string, mode, pos string, ptalog, out io.Writer, buildContext *build.Context) error {
|
||||||
|
minfo, ok := modes[mode]
|
||||||
|
if !ok {
|
||||||
|
if mode == "" {
|
||||||
|
return errors.New("You must specify a -mode to perform.")
|
||||||
|
}
|
||||||
|
return fmt.Errorf("Invalid mode type '%s'.", mode)
|
||||||
|
}
|
||||||
|
|
||||||
|
var loader importer.SourceLoader
|
||||||
|
if minfo.needs&WholeSource != 0 {
|
||||||
|
loader = importer.MakeGoBuildLoader(buildContext)
|
||||||
|
}
|
||||||
|
imp := importer.New(&importer.Config{Loader: loader})
|
||||||
|
o := &oracle{
|
||||||
|
out: out,
|
||||||
|
prog: ssa.NewProgram(imp.Fset, 0),
|
||||||
|
timers: make(map[string]time.Duration),
|
||||||
|
}
|
||||||
|
o.config.Log = ptalog
|
||||||
|
|
||||||
|
type warning struct {
|
||||||
|
pos token.Pos
|
||||||
|
format string
|
||||||
|
args []interface{}
|
||||||
|
}
|
||||||
|
var warnings []warning
|
||||||
|
o.config.Warn = func(pos token.Pos, format string, args ...interface{}) {
|
||||||
|
warnings = append(warnings, warning{pos, format, args})
|
||||||
|
}
|
||||||
|
|
||||||
|
// Phase timing diagnostics.
|
||||||
|
if false {
|
||||||
|
defer func() {
|
||||||
|
fmt.Println()
|
||||||
|
for name, duration := range o.timers {
|
||||||
|
fmt.Printf("# %-30s %s\n", name, duration)
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
}
|
||||||
|
|
||||||
|
// Load/parse/type-check program from args.
|
||||||
|
start := time.Now()
|
||||||
|
initialPkgInfo, _, err := importer.CreatePackageFromArgs(imp, args)
|
||||||
|
if err != nil {
|
||||||
|
return err // I/O, parser or type error
|
||||||
|
}
|
||||||
|
o.timers["load/parse/type"] = time.Since(start)
|
||||||
|
|
||||||
|
// Parse the source query position.
|
||||||
|
if minfo.needs&(Pos|ExactPos) != 0 {
|
||||||
|
var err error
|
||||||
|
o.startPos, o.endPos, err = parseQueryPos(o.prog.Fset, pos)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
var exact bool
|
||||||
|
o.queryPkgInfo, o.queryPath, exact = imp.PathEnclosingInterval(o.startPos, o.endPos)
|
||||||
|
if o.queryPath == nil {
|
||||||
|
return o.errorf(o, "no syntax here")
|
||||||
|
}
|
||||||
|
if minfo.needs&ExactPos != 0 && !exact {
|
||||||
|
return o.errorf(o.queryPath[0], "ambiguous selection within %s",
|
||||||
|
importer.NodeDescription(o.queryPath[0]))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create SSA package for the initial package and its dependencies.
|
||||||
|
if minfo.needs&SSA != 0 {
|
||||||
|
start = time.Now()
|
||||||
|
|
||||||
|
// All packages.
|
||||||
|
for _, info := range imp.Packages {
|
||||||
|
o.prog.CreatePackage(info) // create ssa.Package
|
||||||
|
}
|
||||||
|
|
||||||
|
// Initial package (specified on command line)
|
||||||
|
initialPkg := o.prog.Package(initialPkgInfo.Pkg)
|
||||||
|
|
||||||
|
// Add package to the pointer analysis scope.
|
||||||
|
if initialPkg.Func("main") == nil {
|
||||||
|
if initialPkg.CreateTestMainFunction() == nil {
|
||||||
|
return o.errorf(o, "analysis scope has no main() entry points")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
o.config.Mains = append(o.config.Mains, initialPkg)
|
||||||
|
|
||||||
|
// Query package.
|
||||||
|
if o.queryPkgInfo != nil {
|
||||||
|
pkg := o.prog.Package(o.queryPkgInfo.Pkg)
|
||||||
|
pkg.SetDebugMode(true)
|
||||||
|
pkg.Build()
|
||||||
|
}
|
||||||
|
|
||||||
|
o.timers["SSA-create"] = time.Since(start)
|
||||||
|
}
|
||||||
|
|
||||||
|
// SSA is built and we have query{Path,PkgInfo}.
|
||||||
|
// Release the other ASTs and type info to the GC.
|
||||||
|
imp = nil
|
||||||
|
|
||||||
|
result, err := minfo.impl(o)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
// TODO(adonovan): use this as a seam for testing.
|
||||||
|
result.display(o)
|
||||||
|
|
||||||
|
// Print warnings after the main output.
|
||||||
|
if warnings != nil {
|
||||||
|
fmt.Fprintln(o.out, "\nPointer analysis warnings:")
|
||||||
|
for _, w := range warnings {
|
||||||
|
o.fprintf(o.out, w.pos, "warning: "+w.format, w.args...)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// ---------- Utilities ----------
|
||||||
|
|
||||||
|
// buildSSA constructs the SSA representation of Go-source function bodies.
|
||||||
|
// Not needed in simpler modes, e.g. freevars.
|
||||||
|
//
|
||||||
|
func buildSSA(o *oracle) {
|
||||||
|
start := time.Now()
|
||||||
|
o.prog.BuildAll()
|
||||||
|
o.timers["SSA-build"] = time.Since(start)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ptrAnalysis runs the pointer analysis and returns the synthetic
|
||||||
|
// root of the callgraph.
|
||||||
|
//
|
||||||
|
func ptrAnalysis(o *oracle) pointer.CallGraphNode {
|
||||||
|
start := time.Now()
|
||||||
|
root := pointer.Analyze(&o.config)
|
||||||
|
o.timers["pointer analysis"] = time.Since(start)
|
||||||
|
return root
|
||||||
|
}
|
||||||
|
|
||||||
|
// parseQueryPos parses a string of the form "file pos" or file
|
||||||
|
// start-end" where pos, start, end are decimal integers, and returns
|
||||||
|
// the extent to which it refers.
|
||||||
|
//
|
||||||
|
func parseQueryPos(fset *token.FileSet, queryPos string) (start, end token.Pos, err error) {
|
||||||
|
if queryPos == "" {
|
||||||
|
err = fmt.Errorf("no source position specified (-pos flag)")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var filename string
|
||||||
|
var startOffset, endOffset int
|
||||||
|
n, err := fmt.Sscanf(queryPos, "%s %d-%d", &filename, &startOffset, &endOffset)
|
||||||
|
if n != 3 {
|
||||||
|
n, err = fmt.Sscanf(queryPos, "%s %d", &filename, &startOffset)
|
||||||
|
if n != 2 {
|
||||||
|
err = fmt.Errorf("invalid source position -pos=%q", queryPos)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
endOffset = startOffset
|
||||||
|
}
|
||||||
|
|
||||||
|
var file *token.File
|
||||||
|
fset.Iterate(func(f *token.File) bool {
|
||||||
|
if sameFile(filename, f.Name()) {
|
||||||
|
// (f.Name() is absolute)
|
||||||
|
file = f
|
||||||
|
return false // done
|
||||||
|
}
|
||||||
|
return true // continue
|
||||||
|
})
|
||||||
|
if file == nil {
|
||||||
|
err = fmt.Errorf("couldn't find file containing position -pos=%q", queryPos)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Range check [start..end], inclusive of both end-points.
|
||||||
|
|
||||||
|
if 0 <= startOffset && startOffset <= file.Size() {
|
||||||
|
start = file.Pos(int(startOffset))
|
||||||
|
} else {
|
||||||
|
err = fmt.Errorf("start position is beyond end of file -pos=%q", queryPos)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if 0 <= endOffset && endOffset <= file.Size() {
|
||||||
|
end = file.Pos(int(endOffset))
|
||||||
|
} else {
|
||||||
|
err = fmt.Errorf("end position is beyond end of file -pos=%q", queryPos)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// sameFile returns true if x and y have the same basename and denote
|
||||||
|
// the same file.
|
||||||
|
//
|
||||||
|
func sameFile(x, y string) bool {
|
||||||
|
if filepath.Base(x) == filepath.Base(y) { // (optimisation)
|
||||||
|
if xi, err := os.Stat(x); err == nil {
|
||||||
|
if yi, err := os.Stat(y); err == nil {
|
||||||
|
return os.SameFile(xi, yi)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
|
||||||
|
// unparen returns e with any enclosing parentheses stripped.
|
||||||
|
func unparen(e ast.Expr) ast.Expr {
|
||||||
|
for {
|
||||||
|
p, ok := e.(*ast.ParenExpr)
|
||||||
|
if !ok {
|
||||||
|
break
|
||||||
|
}
|
||||||
|
e = p.X
|
||||||
|
}
|
||||||
|
return 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.
|
||||||
|
// - o *oracle, meaning the extent [o.startPos, o.endPos) 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.
|
||||||
|
// TODO(adonovan): support other editors.
|
||||||
|
//
|
||||||
|
func (o *oracle) fprintf(w io.Writer, 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 interface {
|
||||||
|
Pos() token.Pos
|
||||||
|
}:
|
||||||
|
start = pos.Pos()
|
||||||
|
end = start
|
||||||
|
case *oracle:
|
||||||
|
start = o.startPos
|
||||||
|
end = o.endPos
|
||||||
|
case nil:
|
||||||
|
// no-op
|
||||||
|
default:
|
||||||
|
panic(fmt.Sprintf("invalid pos: %T", pos))
|
||||||
|
}
|
||||||
|
|
||||||
|
if sp := o.prog.Fset.Position(start); start == end {
|
||||||
|
// (prints "-: " for token.NoPos)
|
||||||
|
fmt.Fprintf(w, "%s: ", sp)
|
||||||
|
} else {
|
||||||
|
ep := o.prog.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")
|
||||||
|
}
|
||||||
|
|
||||||
|
// printf is like fprintf, but writes to to o.out.
|
||||||
|
func (o *oracle) printf(pos interface{}, format string, args ...interface{}) {
|
||||||
|
o.fprintf(o.out, pos, format, args...)
|
||||||
|
}
|
||||||
|
|
||||||
|
// errorf is like fprintf, but returns a formatted error string.
|
||||||
|
func (o *oracle) errorf(pos interface{}, format string, args ...interface{}) error {
|
||||||
|
var buf bytes.Buffer
|
||||||
|
o.fprintf(&buf, pos, format, args...)
|
||||||
|
return errors.New(buf.String())
|
||||||
|
}
|
||||||
|
|
||||||
|
// printNode returns the pretty-printed syntax of n.
|
||||||
|
func (o *oracle) printNode(n ast.Node) string {
|
||||||
|
var buf bytes.Buffer
|
||||||
|
printer.Fprint(&buf, o.prog.Fset, n)
|
||||||
|
return buf.String()
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,218 @@
|
||||||
|
package oracle_test
|
||||||
|
|
||||||
|
// This file defines a test framework for oracle queries.
|
||||||
|
//
|
||||||
|
// The files beneath testdata/src/main contain Go programs containing
|
||||||
|
// query annotations of the form:
|
||||||
|
//
|
||||||
|
// @verb id "select"
|
||||||
|
//
|
||||||
|
// where verb is the query mode (e.g. "callers"), id is a unique name
|
||||||
|
// for this query, and "select" is a regular expression matching the
|
||||||
|
// substring of the current line that is the query's input selection.
|
||||||
|
//
|
||||||
|
// The expected output for each query is provided in the accompanying
|
||||||
|
// .golden file.
|
||||||
|
//
|
||||||
|
// (Location information is not included because it's too fragile to
|
||||||
|
// display as text. TODO(adonovan): think about how we can test its
|
||||||
|
// correctness, since it is critical information.)
|
||||||
|
//
|
||||||
|
// Run this test with:
|
||||||
|
// % go test code.google.com/p/go.tools/oracle -update
|
||||||
|
// to update the golden files.
|
||||||
|
|
||||||
|
// TODO(adonovan): improve coverage:
|
||||||
|
// - output of @callgraph is nondeterministic.
|
||||||
|
// - as are lists of labels.
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"flag"
|
||||||
|
"fmt"
|
||||||
|
"go/build"
|
||||||
|
"go/parser"
|
||||||
|
"go/token"
|
||||||
|
"io"
|
||||||
|
"io/ioutil"
|
||||||
|
"os"
|
||||||
|
"os/exec"
|
||||||
|
"regexp"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/oracle"
|
||||||
|
)
|
||||||
|
|
||||||
|
var updateFlag = flag.Bool("update", false, "Update the golden files.")
|
||||||
|
|
||||||
|
type query struct {
|
||||||
|
id string // unique id
|
||||||
|
verb string // query mode, e.g. "callees"
|
||||||
|
posn token.Position // position of of query
|
||||||
|
filename string
|
||||||
|
start, end int // selection of file to pass to oracle
|
||||||
|
}
|
||||||
|
|
||||||
|
func parseRegexp(text string) (*regexp.Regexp, error) {
|
||||||
|
pattern, err := strconv.Unquote(text)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("can't unquote %s", text)
|
||||||
|
}
|
||||||
|
return regexp.Compile(pattern)
|
||||||
|
}
|
||||||
|
|
||||||
|
// parseQueries parses and returns the queries in the named file.
|
||||||
|
func parseQueries(t *testing.T, filename string) []*query {
|
||||||
|
filedata, err := ioutil.ReadFile(filename)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parse the file once to discover the test queries.
|
||||||
|
var fset token.FileSet
|
||||||
|
f, err := parser.ParseFile(&fset, filename, filedata,
|
||||||
|
parser.DeclarationErrors|parser.ParseComments)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
lines := bytes.Split(filedata, []byte("\n"))
|
||||||
|
|
||||||
|
var queries []*query
|
||||||
|
queriesById := make(map[string]*query)
|
||||||
|
|
||||||
|
// Find all annotations of these forms:
|
||||||
|
expectRe := regexp.MustCompile(`@([a-z]+)\s+(\S+)\s+(\".*)$`) // @verb id "regexp"
|
||||||
|
for _, c := range f.Comments {
|
||||||
|
text := strings.TrimSpace(c.Text())
|
||||||
|
if text == "" || text[0] != '@' {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
posn := fset.Position(c.Pos())
|
||||||
|
|
||||||
|
// @verb id "regexp"
|
||||||
|
match := expectRe.FindStringSubmatch(text)
|
||||||
|
if match == nil {
|
||||||
|
t.Errorf("%s: ill-formed query: %s", posn, text)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
id := match[2]
|
||||||
|
if prev, ok := queriesById[id]; ok {
|
||||||
|
t.Errorf("%s: duplicate id %s", posn, id)
|
||||||
|
t.Errorf("%s: previously used here", prev.posn)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
selectRe, err := parseRegexp(match[3])
|
||||||
|
if err != nil {
|
||||||
|
t.Errorf("%s: %s", posn, err)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find text of the current line, sans query.
|
||||||
|
// (Queries must be // not /**/ comments.)
|
||||||
|
line := lines[posn.Line-1][:posn.Column-1]
|
||||||
|
|
||||||
|
// Apply regexp to current line to find input selection.
|
||||||
|
loc := selectRe.FindIndex(line)
|
||||||
|
if loc == nil {
|
||||||
|
t.Errorf("%s: selection pattern %s doesn't match line %q",
|
||||||
|
posn, match[3], string(line))
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// Assumes ASCII. TODO(adonovan): test on UTF-8.
|
||||||
|
linestart := posn.Offset - (posn.Column - 1)
|
||||||
|
|
||||||
|
// Compute the file offsets
|
||||||
|
q := &query{
|
||||||
|
id: id,
|
||||||
|
verb: match[1],
|
||||||
|
posn: posn,
|
||||||
|
filename: filename,
|
||||||
|
start: linestart + loc[0],
|
||||||
|
end: linestart + loc[1],
|
||||||
|
}
|
||||||
|
queries = append(queries, q)
|
||||||
|
queriesById[id] = q
|
||||||
|
}
|
||||||
|
|
||||||
|
// Return the slice, not map, for deterministic iteration.
|
||||||
|
return queries
|
||||||
|
}
|
||||||
|
|
||||||
|
// stripLocation removes a "file:line: " prefix.
|
||||||
|
func stripLocation(line string) string {
|
||||||
|
if i := strings.Index(line, ": "); i >= 0 {
|
||||||
|
line = line[i+2:]
|
||||||
|
}
|
||||||
|
return line
|
||||||
|
}
|
||||||
|
|
||||||
|
// doQuery poses query q to the oracle and writes its response and
|
||||||
|
// error (if any) to out.
|
||||||
|
func doQuery(out io.Writer, q *query) {
|
||||||
|
fmt.Fprintf(out, "-------- @%s %s --------\n", q.verb, q.id)
|
||||||
|
|
||||||
|
capture := new(bytes.Buffer) // capture standard output
|
||||||
|
var buildContext = build.Default
|
||||||
|
buildContext.GOPATH = "testdata"
|
||||||
|
err := oracle.Main([]string{q.filename},
|
||||||
|
q.verb,
|
||||||
|
fmt.Sprintf("%s %d-%d", q.filename, q.start, q.end),
|
||||||
|
/*PTA-log=*/ nil, capture, &buildContext)
|
||||||
|
|
||||||
|
for _, line := range strings.Split(capture.String(), "\n") {
|
||||||
|
fmt.Fprintf(out, "%s\n", stripLocation(line))
|
||||||
|
}
|
||||||
|
|
||||||
|
if err != nil {
|
||||||
|
fmt.Fprintf(out, "Error: %s\n", stripLocation(err.Error()))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestOracle(t *testing.T) {
|
||||||
|
for _, filename := range []string{
|
||||||
|
"testdata/src/main/calls.go",
|
||||||
|
"testdata/src/main/describe.go",
|
||||||
|
"testdata/src/main/freevars.go",
|
||||||
|
"testdata/src/main/implements.go",
|
||||||
|
"testdata/src/main/imports.go",
|
||||||
|
"testdata/src/main/peers.go",
|
||||||
|
} {
|
||||||
|
queries := parseQueries(t, filename)
|
||||||
|
golden := filename + "lden"
|
||||||
|
got := filename + "t"
|
||||||
|
gotfh, err := os.Create(got)
|
||||||
|
if err != nil {
|
||||||
|
t.Errorf("Create(%s) failed: %s", got, err)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
defer gotfh.Close()
|
||||||
|
|
||||||
|
// Run the oracle on each query, redirecting its output
|
||||||
|
// and error (if any) to the foo.got file.
|
||||||
|
for _, q := range queries {
|
||||||
|
doQuery(gotfh, q)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compare foo.got with foo.golden.
|
||||||
|
cmd := exec.Command("/usr/bin/diff", "-u3", golden, got) // assumes POSIX
|
||||||
|
buf := new(bytes.Buffer)
|
||||||
|
cmd.Stdout = buf
|
||||||
|
if err := cmd.Run(); err != nil {
|
||||||
|
t.Errorf("Oracle tests for %s failed: %s.\n%s\n",
|
||||||
|
filename, err, buf)
|
||||||
|
|
||||||
|
if *updateFlag {
|
||||||
|
t.Logf("Updating %s...", golden)
|
||||||
|
if err := exec.Command("/bin/cp", got, golden).Run(); err != nil {
|
||||||
|
t.Errorf("Update failed: %s", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,147 @@
|
||||||
|
package oracle
|
||||||
|
|
||||||
|
import (
|
||||||
|
"go/ast"
|
||||||
|
"go/token"
|
||||||
|
|
||||||
|
"code.google.com/p/go.tools/go/types"
|
||||||
|
"code.google.com/p/go.tools/pointer"
|
||||||
|
"code.google.com/p/go.tools/ssa"
|
||||||
|
)
|
||||||
|
|
||||||
|
// peers enumerates, for a given channel send (or receive) operation,
|
||||||
|
// the set of possible receives (or sends) that correspond to it.
|
||||||
|
//
|
||||||
|
// TODO(adonovan): support reflect.{Select,Recv,Send}.
|
||||||
|
// TODO(adonovan): permit the user to query based on a MakeChan (not send/recv),
|
||||||
|
// or the implicit receive in "for v := range ch".
|
||||||
|
//
|
||||||
|
func peers(o *oracle) (queryResult, error) {
|
||||||
|
// Determine the enclosing send/receive op for the specified position.
|
||||||
|
var arrowPos token.Pos
|
||||||
|
for _, n := range o.queryPath {
|
||||||
|
switch n := n.(type) {
|
||||||
|
case *ast.UnaryExpr:
|
||||||
|
if n.Op == token.ARROW {
|
||||||
|
arrowPos = n.OpPos
|
||||||
|
goto found
|
||||||
|
}
|
||||||
|
case *ast.SendStmt:
|
||||||
|
arrowPos = n.Arrow
|
||||||
|
goto found
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return nil, o.errorf(o.queryPath[0], "there is no send/receive here")
|
||||||
|
found:
|
||||||
|
|
||||||
|
buildSSA(o)
|
||||||
|
|
||||||
|
var queryOp chanOp // the originating send or receive operation
|
||||||
|
var ops []chanOp // all sends/receives of opposite direction
|
||||||
|
|
||||||
|
// Look at all send/receive instructions in the whole ssa.Program.
|
||||||
|
// Build a list of those of same type to query.
|
||||||
|
allFuncs := ssa.AllFunctions(o.prog)
|
||||||
|
for fn := range allFuncs {
|
||||||
|
for _, b := range fn.Blocks {
|
||||||
|
for _, instr := range b.Instrs {
|
||||||
|
for _, op := range chanOps(instr) {
|
||||||
|
ops = append(ops, op)
|
||||||
|
if op.pos == arrowPos {
|
||||||
|
queryOp = op // we found the query op
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if queryOp.ch == nil {
|
||||||
|
return nil, o.errorf(arrowPos, "ssa.Instruction for send/receive not found")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Discard operations of wrong channel element type.
|
||||||
|
// Build set of channel ssa.Values as query to pointer analysis.
|
||||||
|
queryElemType := queryOp.ch.Type().Underlying().(*types.Chan).Elem()
|
||||||
|
channels := map[ssa.Value][]pointer.Pointer{queryOp.ch: nil}
|
||||||
|
i := 0
|
||||||
|
for _, op := range ops {
|
||||||
|
if types.IsIdentical(op.ch.Type().Underlying().(*types.Chan).Elem(), queryElemType) {
|
||||||
|
channels[op.ch] = nil
|
||||||
|
ops[i] = op
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
ops = ops[:i]
|
||||||
|
|
||||||
|
// Run the pointer analysis.
|
||||||
|
o.config.QueryValues = channels
|
||||||
|
ptrAnalysis(o)
|
||||||
|
|
||||||
|
// Combine the PT sets from all contexts.
|
||||||
|
queryChanPts := pointer.PointsToCombined(channels[queryOp.ch])
|
||||||
|
|
||||||
|
return &peersResult{
|
||||||
|
queryOp: queryOp,
|
||||||
|
ops: ops,
|
||||||
|
queryChanPts: queryChanPts,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// chanOp abstracts an ssa.Send, ssa.Unop(ARROW), or a SelectState.
|
||||||
|
type chanOp struct {
|
||||||
|
ch ssa.Value
|
||||||
|
dir ast.ChanDir
|
||||||
|
pos token.Pos
|
||||||
|
}
|
||||||
|
|
||||||
|
// chanOps returns a slice of all the channel operations in the instruction.
|
||||||
|
func chanOps(instr ssa.Instruction) []chanOp {
|
||||||
|
// TODO(adonovan): handle calls to reflect.{Select,Recv,Send} too.
|
||||||
|
var ops []chanOp
|
||||||
|
switch instr := instr.(type) {
|
||||||
|
case *ssa.UnOp:
|
||||||
|
if instr.Op == token.ARROW {
|
||||||
|
ops = append(ops, chanOp{instr.X, ast.RECV, instr.Pos()})
|
||||||
|
}
|
||||||
|
case *ssa.Send:
|
||||||
|
ops = append(ops, chanOp{instr.Chan, ast.SEND, instr.Pos()})
|
||||||
|
case *ssa.Select:
|
||||||
|
for _, st := range instr.States {
|
||||||
|
ops = append(ops, chanOp{st.Chan, st.Dir, st.Pos})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return ops
|
||||||
|
}
|
||||||
|
|
||||||
|
type peersResult struct {
|
||||||
|
queryOp chanOp
|
||||||
|
ops []chanOp
|
||||||
|
queryChanPts pointer.PointsToSet
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *peersResult) display(o *oracle) {
|
||||||
|
// Report which make(chan) labels the query's channel can alias.
|
||||||
|
labels := r.queryChanPts.Labels()
|
||||||
|
if len(labels) == 0 {
|
||||||
|
o.printf(r.queryOp.pos, "This channel can't point to anything.")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
o.printf(r.queryOp.pos, "This channel of type %s may be:", r.queryOp.ch.Type())
|
||||||
|
// TODO(adonovan): sort, to ensure test determinism.
|
||||||
|
for _, label := range labels {
|
||||||
|
o.printf(label, "\tallocated here")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Report which send/receive operations can alias the same make(chan) labels.
|
||||||
|
for _, op := range r.ops {
|
||||||
|
// TODO(adonovan): sort, to ensure test determinism.
|
||||||
|
for _, ptr := range o.config.QueryValues[op.ch] {
|
||||||
|
if ptr != nil && ptr.PointsTo().Intersects(r.queryChanPts) {
|
||||||
|
verb := "received from"
|
||||||
|
if op.dir == ast.SEND {
|
||||||
|
verb = "sent to"
|
||||||
|
}
|
||||||
|
o.printf(op.pos, "\t%s, here", verb)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,14 @@
|
||||||
|
package lib
|
||||||
|
|
||||||
|
type Type int
|
||||||
|
|
||||||
|
func (Type) Method(x *int) *int {
|
||||||
|
return x
|
||||||
|
}
|
||||||
|
|
||||||
|
func Func() {
|
||||||
|
}
|
||||||
|
|
||||||
|
const Const = 3
|
||||||
|
|
||||||
|
var Var = 0
|
||||||
|
|
@ -0,0 +1,86 @@
|
||||||
|
package main
|
||||||
|
|
||||||
|
// Tests of call-graph queries.
|
||||||
|
// See go.tools/oracle/oracle_test.go for explanation.
|
||||||
|
// See calls.golden for expected query results.
|
||||||
|
|
||||||
|
func A(x *int) { // @describe describe-A-x "x"
|
||||||
|
// @callers callers-A "^"
|
||||||
|
// @callstack callstack-A "^"
|
||||||
|
}
|
||||||
|
|
||||||
|
func B(x *int) { // @describe describe-B-x "x"
|
||||||
|
// @callers callers-B "^"
|
||||||
|
}
|
||||||
|
|
||||||
|
// apply is not (yet) treated context-sensitively.
|
||||||
|
func apply(f func(x *int), x *int) {
|
||||||
|
f(x) // @callees callees-apply "f"
|
||||||
|
// @callers callers-apply "^"
|
||||||
|
}
|
||||||
|
|
||||||
|
// store *is* treated context-sensitively,
|
||||||
|
// so the points-to sets for pc, pd are precise.
|
||||||
|
func store(ptr **int, value *int) {
|
||||||
|
*ptr = value
|
||||||
|
// @callers callers-store "^"
|
||||||
|
}
|
||||||
|
|
||||||
|
func call(f func() *int) {
|
||||||
|
// Result points to anon function.
|
||||||
|
f() // @describe describe-result-f "f"
|
||||||
|
|
||||||
|
// Target of call is anon function.
|
||||||
|
f() // @callees callees-main.call-f "f"
|
||||||
|
|
||||||
|
// @callers callers-main.call "^"
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
var a, b int
|
||||||
|
apply(A, &a) // @callees callees-main-apply1 "app"
|
||||||
|
apply(B, &b)
|
||||||
|
|
||||||
|
var c, d int
|
||||||
|
var pc, pd *int // @describe describe-pc "pc"
|
||||||
|
store(&pc, &c)
|
||||||
|
store(&pd, &d)
|
||||||
|
_ = pd // @describe describe-pd "pd"
|
||||||
|
|
||||||
|
call(func() *int {
|
||||||
|
// We are called twice from main.call
|
||||||
|
// @callers callers-main.anon "^"
|
||||||
|
return &a
|
||||||
|
})
|
||||||
|
|
||||||
|
// Errors
|
||||||
|
_ = "no function call here" // @callees callees-err-no-call "no"
|
||||||
|
print("builtin") // @callees callees-err-builtin "builtin"
|
||||||
|
_ = string("type conversion") // @callees callees-err-conversion "str"
|
||||||
|
call(nil) // @callees callees-err-bad-selection "call\\(nil"
|
||||||
|
if false {
|
||||||
|
main() // @callees callees-err-deadcode1 "main"
|
||||||
|
}
|
||||||
|
var nilFunc func()
|
||||||
|
nilFunc() // @callees callees-err-nil-func "nilFunc"
|
||||||
|
var i interface {
|
||||||
|
f()
|
||||||
|
}
|
||||||
|
i.f() // @callees callees-err-nil-interface "i.f"
|
||||||
|
}
|
||||||
|
|
||||||
|
func deadcode() {
|
||||||
|
main() // @callees callees-err-deadcode2 "main"
|
||||||
|
// @callers callers-err-deadcode "^"
|
||||||
|
// @callstack callstack-err-deadcode "^"
|
||||||
|
}
|
||||||
|
|
||||||
|
// This code belongs to init.
|
||||||
|
var global = 123 // @callers callers-global "global"
|
||||||
|
|
||||||
|
// init may be called by other packages' inits, or in this case, the
|
||||||
|
// root of the callgraph.
|
||||||
|
func init() {
|
||||||
|
// @callers callers-init "^"
|
||||||
|
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,106 @@
|
||||||
|
-------- @describe describe-A-x --------
|
||||||
|
definition of var x *int
|
||||||
|
value may point to these labels:
|
||||||
|
a
|
||||||
|
b
|
||||||
|
|
||||||
|
-------- @callstack callstack-A --------
|
||||||
|
Found a call path from root to main.A
|
||||||
|
main.A
|
||||||
|
dynamic function call from main.apply
|
||||||
|
static function call from main.main
|
||||||
|
|
||||||
|
-------- @describe describe-B-x --------
|
||||||
|
definition of var x *int
|
||||||
|
value may point to these labels:
|
||||||
|
a
|
||||||
|
b
|
||||||
|
|
||||||
|
-------- @callers callers-B --------
|
||||||
|
main.B is called from these 1 sites:
|
||||||
|
dynamic function call from main.apply
|
||||||
|
|
||||||
|
-------- @callees callees-apply --------
|
||||||
|
this dynamic function call dispatches to:
|
||||||
|
main.A
|
||||||
|
main.B
|
||||||
|
|
||||||
|
-------- @callers callers-apply --------
|
||||||
|
main.apply is called from these 2 sites:
|
||||||
|
static function call from main.main
|
||||||
|
static function call from main.main
|
||||||
|
|
||||||
|
-------- @callers callers-store --------
|
||||||
|
main.store is called from these 2 sites:
|
||||||
|
static function call from main.main
|
||||||
|
static function call from main.main
|
||||||
|
|
||||||
|
-------- @describe describe-result-f --------
|
||||||
|
reference to var f func() *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
func@50.7
|
||||||
|
|
||||||
|
-------- @callees callees-main.call-f --------
|
||||||
|
this dynamic function call dispatches to:
|
||||||
|
func@50.7
|
||||||
|
|
||||||
|
-------- @callers callers-main.call --------
|
||||||
|
main.call is called from these 2 sites:
|
||||||
|
static function call from main.main
|
||||||
|
static function call from main.main
|
||||||
|
|
||||||
|
-------- @callees callees-main-apply1 --------
|
||||||
|
this static function call dispatches to:
|
||||||
|
main.apply
|
||||||
|
|
||||||
|
-------- @describe describe-pc --------
|
||||||
|
definition of var pc *int
|
||||||
|
value may point to these labels:
|
||||||
|
c
|
||||||
|
|
||||||
|
-------- @describe describe-pd --------
|
||||||
|
reference to var pd *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
d
|
||||||
|
|
||||||
|
-------- @callees callees-err-no-call --------
|
||||||
|
|
||||||
|
Error: there is no function call here
|
||||||
|
|
||||||
|
-------- @callees callees-err-builtin --------
|
||||||
|
|
||||||
|
Error: this is a call to the built-in 'print' operator
|
||||||
|
|
||||||
|
-------- @callees callees-err-conversion --------
|
||||||
|
|
||||||
|
Error: this is a type conversion, not a function call
|
||||||
|
|
||||||
|
-------- @callees callees-err-bad-selection --------
|
||||||
|
|
||||||
|
Error: ambiguous selection within function call (or conversion)
|
||||||
|
|
||||||
|
-------- @callees callees-err-deadcode1 --------
|
||||||
|
this call site is unreachable in this analysis
|
||||||
|
|
||||||
|
-------- @callees callees-err-nil-func --------
|
||||||
|
dynamic function call on nil value
|
||||||
|
|
||||||
|
-------- @callees callees-err-nil-interface --------
|
||||||
|
dynamic method call on nil value
|
||||||
|
|
||||||
|
-------- @callees callees-err-deadcode2 --------
|
||||||
|
this call site is unreachable in this analysis
|
||||||
|
|
||||||
|
-------- @callstack callstack-err-deadcode --------
|
||||||
|
main.deadcode is unreachable in this analysis scope
|
||||||
|
|
||||||
|
-------- @callers callers-global --------
|
||||||
|
main.init is called from these 1 sites:
|
||||||
|
the root of the call graph
|
||||||
|
|
||||||
|
-------- @callers callers-init --------
|
||||||
|
main.init is called from these 1 sites:
|
||||||
|
the root of the call graph
|
||||||
|
|
||||||
|
|
@ -0,0 +1,75 @@
|
||||||
|
package describe // @describe pkgdecl "describe"
|
||||||
|
|
||||||
|
// Tests of 'describe' query.
|
||||||
|
// See go.tools/oracle/oracle_test.go for explanation.
|
||||||
|
// See describe.golden for expected query results.
|
||||||
|
|
||||||
|
// TODO(adonovan): more coverage of the (extensive) logic.
|
||||||
|
|
||||||
|
type cake float64 // @describe type-ref-builtin "float64"
|
||||||
|
|
||||||
|
const pi = 3.141 // @describe const-def-pi "pi"
|
||||||
|
const pie = cake(pi) // @describe const-def-pie "pie"
|
||||||
|
const _ = pi // @describe const-ref-pi "pi"
|
||||||
|
|
||||||
|
func main() { // @describe func-def-main "main"
|
||||||
|
// func objects
|
||||||
|
_ = main // @describe func-ref-main "main"
|
||||||
|
_ = (*C).f // @describe func-ref-*C.f "..C..f"
|
||||||
|
_ = D.f // @describe func-ref-D.f "D.f"
|
||||||
|
_ = I.f // @describe func-ref-I.f "I.f"
|
||||||
|
var d D // @describe type-D "D"
|
||||||
|
var i I // @describe type-I "I"
|
||||||
|
_ = d.f // @describe func-ref-d.f "d.f"
|
||||||
|
_ = i.f // @describe func-ref-i.f "i.f"
|
||||||
|
|
||||||
|
// var objects
|
||||||
|
anon := func() {
|
||||||
|
_ = d // @describe ref-lexical-d "d"
|
||||||
|
}
|
||||||
|
_ = anon // @describe ref-anon "anon"
|
||||||
|
|
||||||
|
// SSA affords some local flow sensitivity.
|
||||||
|
var a, b int
|
||||||
|
var x = &a // @describe var-def-x-1 "x"
|
||||||
|
_ = x // @describe var-ref-x-1 "x"
|
||||||
|
x = &b // @describe var-def-x-2 "x"
|
||||||
|
_ = x // @describe var-ref-x-2 "x"
|
||||||
|
|
||||||
|
// const objects
|
||||||
|
const localpi = 3.141 // @describe const-local-pi "localpi"
|
||||||
|
const localpie = cake(pi) // @describe const-local-pie "localpie"
|
||||||
|
const _ = localpi // @describe const-ref-localpi "localpi"
|
||||||
|
|
||||||
|
// type objects
|
||||||
|
type T int // @describe type-def-T "T"
|
||||||
|
var three T = 3 // @describe type-ref-T "T"
|
||||||
|
|
||||||
|
print(1 + 2*3) // @describe const-expr " 2.3"
|
||||||
|
print(real(1+2i) - 3) // @describe const-expr2 "real.*3"
|
||||||
|
|
||||||
|
m := map[string]*int{"a": &a}
|
||||||
|
// TODO(adonovan): fix spurious error in map-lookup,ok result.
|
||||||
|
mapval, _ := m["a"] // @describe map-lookup,ok "m..a.."
|
||||||
|
_ = mapval // @describe mapval "mapval"
|
||||||
|
_ = m // @describe m "m"
|
||||||
|
|
||||||
|
defer main() // @describe defer-stmt "defer"
|
||||||
|
go main() // @describe go-stmt "go"
|
||||||
|
}
|
||||||
|
|
||||||
|
func deadcode() {
|
||||||
|
var a int // @describe var-decl-stmt "var a int"
|
||||||
|
// Pointer analysis can't run on dead code.
|
||||||
|
var b = &a // @describe b "b"
|
||||||
|
}
|
||||||
|
|
||||||
|
type I interface { // @describe def-iface-I "I"
|
||||||
|
f() // @describe def-imethod-I.f "f"
|
||||||
|
}
|
||||||
|
|
||||||
|
type C int
|
||||||
|
type D struct{}
|
||||||
|
|
||||||
|
func (c *C) f() {}
|
||||||
|
func (d D) f() {}
|
||||||
|
|
@ -0,0 +1,165 @@
|
||||||
|
-------- @describe pkgdecl --------
|
||||||
|
definition of package "main"
|
||||||
|
type C int
|
||||||
|
method (*describe.C) f()
|
||||||
|
type D struct{}
|
||||||
|
method (describe.D) f()
|
||||||
|
type I interface{f()}
|
||||||
|
method (describe.I) f()
|
||||||
|
type cake float64
|
||||||
|
func deadcode func()
|
||||||
|
func init func()
|
||||||
|
var init$guard bool
|
||||||
|
func main func()
|
||||||
|
const pi untyped float = 3141/1000:untyped float
|
||||||
|
const pie describe.cake = 1768225803696341/562949953421312:describe.cake
|
||||||
|
|
||||||
|
-------- @describe type-ref-builtin --------
|
||||||
|
reference to built-in type float64
|
||||||
|
|
||||||
|
-------- @describe const-def-pi --------
|
||||||
|
definition of const pi untyped float
|
||||||
|
|
||||||
|
-------- @describe const-def-pie --------
|
||||||
|
definition of const pie describe.cake
|
||||||
|
|
||||||
|
-------- @describe const-ref-pi --------
|
||||||
|
reference to const pi untyped float of constant value 3141/1000
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe func-def-main --------
|
||||||
|
definition of func describe.main()
|
||||||
|
|
||||||
|
-------- @describe func-ref-main --------
|
||||||
|
reference to func describe.main()
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe func-ref-*C.f --------
|
||||||
|
reference to func (*describe.C).f()
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe func-ref-D.f --------
|
||||||
|
reference to func (describe.D).f()
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe func-ref-I.f --------
|
||||||
|
reference to func (describe.I).f()
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe type-D --------
|
||||||
|
reference to type describe.D
|
||||||
|
defined as struct{}
|
||||||
|
Method set:
|
||||||
|
method (describe.D) f()
|
||||||
|
|
||||||
|
-------- @describe type-I --------
|
||||||
|
reference to type describe.I
|
||||||
|
defined as interface{f()}
|
||||||
|
Method set:
|
||||||
|
method (describe.I) f()
|
||||||
|
|
||||||
|
-------- @describe func-ref-d.f --------
|
||||||
|
reference to func (describe.D).f()
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe func-ref-i.f --------
|
||||||
|
reference to func (describe.I).f()
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe ref-lexical-d --------
|
||||||
|
reference to var d describe.D
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe ref-anon --------
|
||||||
|
reference to var anon func()
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
func@27.10
|
||||||
|
|
||||||
|
-------- @describe var-def-x-1 --------
|
||||||
|
definition of var x *int
|
||||||
|
value may point to these labels:
|
||||||
|
a
|
||||||
|
|
||||||
|
-------- @describe var-ref-x-1 --------
|
||||||
|
reference to var x *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
a
|
||||||
|
|
||||||
|
-------- @describe var-def-x-2 --------
|
||||||
|
reference to var x *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
b
|
||||||
|
|
||||||
|
-------- @describe var-ref-x-2 --------
|
||||||
|
reference to var x *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
b
|
||||||
|
|
||||||
|
-------- @describe const-local-pi --------
|
||||||
|
definition of const localpi untyped float
|
||||||
|
|
||||||
|
-------- @describe const-local-pie --------
|
||||||
|
definition of const localpie describe.cake
|
||||||
|
|
||||||
|
-------- @describe const-ref-localpi --------
|
||||||
|
reference to const localpi untyped float of constant value 3141/1000
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe type-def-T --------
|
||||||
|
definition of type describe.T
|
||||||
|
No methods.
|
||||||
|
|
||||||
|
-------- @describe type-ref-T --------
|
||||||
|
reference to type describe.T
|
||||||
|
defined as int
|
||||||
|
No methods.
|
||||||
|
|
||||||
|
-------- @describe const-expr --------
|
||||||
|
binary * operation of constant value 6
|
||||||
|
|
||||||
|
-------- @describe const-expr2 --------
|
||||||
|
binary - operation of constant value -2
|
||||||
|
|
||||||
|
-------- @describe map-lookup,ok --------
|
||||||
|
index expression of type (*int, bool)
|
||||||
|
no pointer analysis: can't locate SSA Value for expression in main.main
|
||||||
|
|
||||||
|
-------- @describe mapval --------
|
||||||
|
reference to var mapval *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
a
|
||||||
|
|
||||||
|
-------- @describe m --------
|
||||||
|
reference to var m map[string]*int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
makemap
|
||||||
|
|
||||||
|
-------- @describe defer-stmt --------
|
||||||
|
defer statement
|
||||||
|
|
||||||
|
-------- @describe go-stmt --------
|
||||||
|
go statement
|
||||||
|
|
||||||
|
-------- @describe var-decl-stmt --------
|
||||||
|
definition of var a int
|
||||||
|
|
||||||
|
-------- @describe b --------
|
||||||
|
definition of var b *int
|
||||||
|
pointer analysis did not analyze this expression (dead code?)
|
||||||
|
|
||||||
|
-------- @describe def-iface-I --------
|
||||||
|
definition of type describe.I
|
||||||
|
Method set:
|
||||||
|
method (describe.I) f()
|
||||||
|
|
||||||
|
-------- @describe def-imethod-I.f --------
|
||||||
|
type interface{f()}
|
||||||
|
Method set:
|
||||||
|
method (interface{f()}) f()
|
||||||
|
|
||||||
|
|
@ -0,0 +1,37 @@
|
||||||
|
package main
|
||||||
|
|
||||||
|
// Tests of 'freevars' query.
|
||||||
|
// See go.tools/oracle/oracle_test.go for explanation.
|
||||||
|
// See freevars.golden for expected query results.
|
||||||
|
|
||||||
|
// TODO(adonovan): it's hard to test this query in a single line of gofmt'd code.
|
||||||
|
|
||||||
|
type T struct {
|
||||||
|
a, b int
|
||||||
|
}
|
||||||
|
|
||||||
|
type S struct {
|
||||||
|
x int
|
||||||
|
t T
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
type C int
|
||||||
|
x := 1
|
||||||
|
const exp = 6
|
||||||
|
if y := 2; x+y+int(C(3)) != exp { // @freevars fv1 "if.*{"
|
||||||
|
panic("expected 6")
|
||||||
|
}
|
||||||
|
|
||||||
|
var s S
|
||||||
|
|
||||||
|
for x, y := range "foo" {
|
||||||
|
println(s.x + s.t.a + s.t.b + x + int(y)) // @freevars fv2 "print.*y."
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO(adonovan): enable when go/types supports labels.
|
||||||
|
loop: // #@freevars fv-def-label "loop:"
|
||||||
|
for {
|
||||||
|
break loop // #@freevars fv-ref-label "break loop"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,14 @@
|
||||||
|
-------- @freevars fv1 --------
|
||||||
|
Free identifers:
|
||||||
|
var x int
|
||||||
|
type C main.C
|
||||||
|
const exp untyped integer
|
||||||
|
|
||||||
|
-------- @freevars fv2 --------
|
||||||
|
Free identifers:
|
||||||
|
var s.x int
|
||||||
|
var s.t.a int
|
||||||
|
var s.t.b int
|
||||||
|
var x int
|
||||||
|
var y int32
|
||||||
|
|
||||||
|
|
@ -0,0 +1,29 @@
|
||||||
|
package main
|
||||||
|
|
||||||
|
// Tests of 'implements' query.
|
||||||
|
// See go.tools/oracle/oracle_test.go for explanation.
|
||||||
|
// See implements.golden for expected query results.
|
||||||
|
|
||||||
|
// @implements impl ""
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
}
|
||||||
|
|
||||||
|
type E interface{}
|
||||||
|
|
||||||
|
type F interface {
|
||||||
|
f()
|
||||||
|
}
|
||||||
|
|
||||||
|
type FG interface {
|
||||||
|
f()
|
||||||
|
g() int
|
||||||
|
}
|
||||||
|
|
||||||
|
type C int
|
||||||
|
type D struct{}
|
||||||
|
|
||||||
|
func (c *C) f() {}
|
||||||
|
func (d D) f() {}
|
||||||
|
|
||||||
|
func (d *D) g() int { return 0 }
|
||||||
|
|
@ -0,0 +1,10 @@
|
||||||
|
-------- @implements impl --------
|
||||||
|
Interface main.E:
|
||||||
|
main.C
|
||||||
|
main.D
|
||||||
|
Interface main.F:
|
||||||
|
*main.C
|
||||||
|
main.D
|
||||||
|
Interface main.FG:
|
||||||
|
*main.D
|
||||||
|
|
||||||
|
|
@ -0,0 +1,26 @@
|
||||||
|
package imports
|
||||||
|
|
||||||
|
import (
|
||||||
|
"lib" // @describe ref-pkg-import "lib"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Tests that import another package. (To make the tests run quickly,
|
||||||
|
// we avoid using imports in all the other tests. Remember, each
|
||||||
|
// query causes parsing and typechecking of the whole program.)
|
||||||
|
//
|
||||||
|
// See go.tools/oracle/oracle_test.go for explanation.
|
||||||
|
// See imports.golden for expected query results.
|
||||||
|
|
||||||
|
var a int
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
const c = lib.Const // @describe ref-const "Const"
|
||||||
|
lib.Func() // @describe ref-func "Func"
|
||||||
|
lib.Var++ // @describe ref-var "Var"
|
||||||
|
var t lib.Type // @describe ref-type "Type"
|
||||||
|
p := t.Method(&a) // @describe ref-method "Method"
|
||||||
|
|
||||||
|
print(*p + 1) // @describe p "p "
|
||||||
|
|
||||||
|
var _ lib.Type // @describe ref-pkg "lib"
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,46 @@
|
||||||
|
-------- @describe ref-pkg-import --------
|
||||||
|
import of package "lib"
|
||||||
|
const Const untyped integer = 3:untyped integer
|
||||||
|
func Func func()
|
||||||
|
type Type int
|
||||||
|
method (lib.Type) Method(x *int) *int
|
||||||
|
var Var int
|
||||||
|
|
||||||
|
-------- @describe ref-const --------
|
||||||
|
reference to const Const untyped integer
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe ref-func --------
|
||||||
|
reference to func lib.Func()
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe ref-var --------
|
||||||
|
reference to var Var int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
lib.Var
|
||||||
|
|
||||||
|
-------- @describe ref-type --------
|
||||||
|
reference to type lib.Type
|
||||||
|
defined as int
|
||||||
|
Method set:
|
||||||
|
method (lib.Type) Method(x *int) *int
|
||||||
|
|
||||||
|
-------- @describe ref-method --------
|
||||||
|
reference to func (lib.Type).Method(x *int) *int
|
||||||
|
defined here
|
||||||
|
|
||||||
|
-------- @describe p --------
|
||||||
|
reference to var p *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
main.a
|
||||||
|
|
||||||
|
-------- @describe ref-pkg --------
|
||||||
|
reference to package "lib"
|
||||||
|
const Const untyped integer = 3:untyped integer
|
||||||
|
func Func func()
|
||||||
|
type Type int
|
||||||
|
method (lib.Type) Method(x *int) *int
|
||||||
|
var Var int
|
||||||
|
|
||||||
|
|
@ -0,0 +1,40 @@
|
||||||
|
package peers
|
||||||
|
|
||||||
|
// Tests of channel 'peers' query.
|
||||||
|
// See go.tools/oracle/oracle_test.go for explanation.
|
||||||
|
// See peers.golden for expected query results.
|
||||||
|
|
||||||
|
var a2 int
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
chA := make(chan *int)
|
||||||
|
a1 := 1
|
||||||
|
chA <- &a1
|
||||||
|
|
||||||
|
chA2 := make(chan *int, 2)
|
||||||
|
if a2 == 0 {
|
||||||
|
chA = chA2
|
||||||
|
}
|
||||||
|
|
||||||
|
chB := make(chan *int)
|
||||||
|
b := 3
|
||||||
|
chB <- &b
|
||||||
|
|
||||||
|
<-chA // @describe describe-chA "chA"
|
||||||
|
<-chA2 // @describe describe-chA2 "chA2"
|
||||||
|
<-chB // @describe describe-chB "chB"
|
||||||
|
|
||||||
|
select {
|
||||||
|
case rA := <-chA: // @peers peer-recv-chA "<-"
|
||||||
|
_ = rA // @describe describe-rA "rA"
|
||||||
|
case rB := <-chB: // @peers peer-recv-chB "<-"
|
||||||
|
_ = rB // @describe describe-rB "rB"
|
||||||
|
|
||||||
|
case <-chA: // @peers peer-recv-chA' "<-"
|
||||||
|
|
||||||
|
case chA2 <- &a2: // @peers peer-send-chA' "<-"
|
||||||
|
}
|
||||||
|
|
||||||
|
for _ = range chA {
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,73 @@
|
||||||
|
-------- @describe describe-chA --------
|
||||||
|
reference to var chA chan *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
makechan
|
||||||
|
makechan
|
||||||
|
|
||||||
|
-------- @describe describe-chA2 --------
|
||||||
|
reference to var chA2 chan *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
makechan
|
||||||
|
|
||||||
|
-------- @describe describe-chB --------
|
||||||
|
reference to var chB chan *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
makechan
|
||||||
|
|
||||||
|
-------- @peers peer-recv-chA --------
|
||||||
|
This channel of type chan *int may be:
|
||||||
|
allocated here
|
||||||
|
allocated here
|
||||||
|
sent to, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
sent to, here
|
||||||
|
received from, here
|
||||||
|
|
||||||
|
-------- @describe describe-rA --------
|
||||||
|
reference to var rA *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
main.a2
|
||||||
|
a1
|
||||||
|
|
||||||
|
-------- @peers peer-recv-chB --------
|
||||||
|
This channel of type chan *int may be:
|
||||||
|
allocated here
|
||||||
|
sent to, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
|
||||||
|
-------- @describe describe-rB --------
|
||||||
|
reference to var rB *int
|
||||||
|
defined here
|
||||||
|
value may point to these labels:
|
||||||
|
b
|
||||||
|
|
||||||
|
-------- @peers peer-recv-chA' --------
|
||||||
|
This channel of type chan *int may be:
|
||||||
|
allocated here
|
||||||
|
allocated here
|
||||||
|
sent to, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
sent to, here
|
||||||
|
received from, here
|
||||||
|
|
||||||
|
-------- @peers peer-send-chA' --------
|
||||||
|
This channel of type chan *int may be:
|
||||||
|
allocated here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
received from, here
|
||||||
|
sent to, here
|
||||||
|
received from, here
|
||||||
|
|
||||||
|
|
@ -14,7 +14,7 @@ func CanPoint(T types.Type) bool {
|
||||||
case *types.Named:
|
case *types.Named:
|
||||||
return CanPoint(T.Underlying())
|
return CanPoint(T.Underlying())
|
||||||
|
|
||||||
case *types.Pointer, *types.Interface, *types.Map, *types.Chan, *types.Signature:
|
case *types.Pointer, *types.Interface, *types.Map, *types.Chan, *types.Signature, *types.Slice:
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue