func done(obj *ast.Object, typ types.Type) {
defer os.Exit(0)
pos := types.FileSet.Position(types.DeclPos(obj))
fmt.Printf("%v\n", pos)
if typ.Kind == ast.Bad || !*tflag {
return
}
fmt.Printf("%s\n", strings.Replace(typeStr(obj, typ), "\n", "\n\t", -1))
if *aflag || *Aflag {
var m orderedObjects
for obj := range typ.Iter(types.DefaultImporter) {
m = append(m, obj)
}
sort.Sort(m)
for _, obj := range m {
// Ignore unexported members unless Aflag is set.
if !*Aflag && (typ.Pkg != "" || !ast.IsExported(obj.Name)) {
continue
}
id := ast.NewIdent(obj.Name)
id.Obj = obj
_, mt := types.ExprType(id, types.DefaultImporter)
fmt.Printf("\t%s\n", strings.Replace(typeStr(obj, mt), "\n", "\n\t\t", -1))
fmt.Printf("\t\t%v\n", types.FileSet.Position(types.DeclPos(obj)))
}
}
}
func (c *listCmd) visit(info *sym.Info, kindMask uint) bool {
if (1<<uint(info.ReferObj.Kind))&kindMask == 0 {
return true
}
if info.Universe {
return true
}
if !c.all && !isExported(info.Ident.Name) {
return true
}
eposition := c.ctxt.position(info.Pos)
exprPkg := c.ctxt.positionToImportPath(eposition)
var referPkg string
if info.Universe {
referPkg = "universe"
} else {
referPkg = c.ctxt.positionToImportPath(c.ctxt.position(info.ReferPos))
}
name := info.Ident.Name
if e, ok := info.Expr.(*ast.SelectorExpr); ok {
_, xt := types.ExprType(e.X, func(path string) *ast.Package {
return c.ctxt.Import(path)
})
// c.ctxt.print("exprtype %s\n", pretty(e.X))
name = e.Sel.Name
switch xn := depointer(xt.Node).(type) {
case nil:
if c.verbose {
log.Printf("%v: no type for %s", c.ctxt.position(e.Pos()), pretty(e.X))
}
return true
case *ast.Ident:
name = xn.Name + "." + name
case *ast.ImportSpec:
// don't qualify with package identifier
default:
// literal struct or interface expression.
name = "_." + name
}
}
line := &symLine{
long: true,
pos: eposition,
referPos: c.ctxt.position(info.ReferPos),
exprPkg: exprPkg,
referPkg: referPkg,
local: info.Local && info.ReferPos == info.Pos,
kind: info.ReferObj.Kind,
plus: info.ReferPos == info.Pos,
expr: name,
}
if c.printType {
line.exprType = pretty(info.ExprType.Node)
}
c.ctxt.printf("%s\n", line)
return true
}
func (ctxt *Context) visitExpr(f *ast.File, e ast.Expr, local bool, visitf func(*Info) bool) bool {
var info Info
info.Expr = e
switch e := e.(type) {
case *ast.Ident:
if e.Name == "_" {
return true
}
info.Pos = e.Pos()
info.Ident = e
case *ast.SelectorExpr:
info.Pos = e.Sel.Pos()
info.Ident = e.Sel
}
obj, t := types.ExprType(e, ctxt.importer)
if obj == nil {
ctxt.logf(e.Pos(), "no object for %s", pretty(e))
return true
}
info.ExprType = t
info.ReferObj = obj
if parser.Universe.Lookup(obj.Name) != obj {
info.ReferPos = types.DeclPos(obj)
if info.ReferPos == token.NoPos {
name := pretty(e)
if name != "init" {
ctxt.logf(e.Pos(), "no declaration for %s", pretty(e))
}
return true
}
} else {
info.Universe = true
}
info.Local = local
oldName := info.Ident.Name
more := visitf(&info)
if info.Ident.Name != oldName {
ctxt.ChangedFiles[ctxt.filename(f)] = f
}
return more
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: godef [flags] [expr]\n")
flag.PrintDefaults()
}
flag.Parse()
if flag.NArg() > 1 {
flag.Usage()
os.Exit(2)
}
types.Debug = *debug
*tflag = *tflag || *aflag || *Aflag
searchpos := *offset
filename := *fflag
var afile *acmeFile
var src []byte
if *acmeFlag {
var err error
if afile, err = acmeCurrentFile(); err != nil {
fail("%v", err)
}
filename, src, searchpos = afile.name, afile.body, afile.offset
} else if *readStdin {
src, _ = ioutil.ReadAll(os.Stdin)
} else {
// TODO if there's no filename, look in the current
// directory and do something plausible.
b, err := ioutil.ReadFile(filename)
if err != nil {
fail("cannot read %s: %v", filename, err)
}
src = b
}
pkgScope := ast.NewScope(parser.Universe)
f, err := parser.ParseFile(types.FileSet, filename, src, 0, pkgScope)
if f == nil {
fail("cannot parse %s: %v", filename, err)
}
var o ast.Node
switch {
case flag.NArg() > 0:
o = parseExpr(f.Scope, flag.Arg(0))
case searchpos >= 0:
o = findIdentifier(f, searchpos)
default:
fmt.Fprintf(os.Stderr, "no expression or offset specified\n")
flag.Usage()
os.Exit(2)
}
// print old source location to facilitate backtracking
if *acmeFlag {
fmt.Printf("\t%s:#%d\n", afile.name, afile.runeOffset)
}
switch e := o.(type) {
case *ast.ImportSpec:
path := importPath(e)
pkg, err := build.Default.Import(path, "", build.FindOnly)
if err != nil {
fail("error finding import path for %s: %s", path, err)
}
fmt.Println(pkg.Dir)
case ast.Expr:
if !*tflag {
// try local declarations only
if obj, typ := types.ExprType(e, types.DefaultImporter); obj != nil {
done(obj, typ)
}
}
// add declarations from other files in the local package and try again
pkg, err := parseLocalPackage(filename, f, pkgScope)
if pkg == nil && !*tflag {
fmt.Printf("parseLocalPackage error: %v\n", err)
}
if obj, typ := types.ExprType(e, types.DefaultImporter); obj != nil {
done(obj, typ)
}
fail("no declaration found for %v", pretty{e})
}
}