func done(obj *ast.Object, typ types.Type, importer types.Importer) {
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(importer) {
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, importer)
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 (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, err := realAbsolutePath(*fflag)
if err != nil {
fail("cannot resolve symlinks in %s: %v", filename, err)
}
var src []byte
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)
}
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:
importer := types.NewImporter(filename)
if !*tflag {
// try local declarations only
if obj, typ := types.ExprType(e, importer); obj != nil {
done(obj, typ, importer)
}
}
// 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 flag.NArg() > 0 {
// Reading declarations in other files might have
// resolved the original expression.
e = parseExpr(f.Scope, flag.Arg(0)).(ast.Expr)
}
if obj, typ := types.ExprType(e, importer); obj != nil {
done(obj, typ, importer)
}
fail("no declaration found for %v", pretty{e})
}
}