// memberFromObject populates package pkg with a member for the
// typechecker object obj.
//
// For objects from Go source code, syntax is the associated syntax
// tree (for funcs and vars only); it will be used during the build
// phase.
//
func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node) {
name := obj.Name()
switch obj := obj.(type) {
case *types.TypeName:
pkg.Members[name] = &Type{object: obj}
case *types.Const:
c := &NamedConst{
object: obj,
Value: NewConst(obj.Val(), obj.Type()),
}
pkg.values[obj] = c.Value
pkg.Members[name] = c
case *types.Var:
spec, _ := syntax.(*ast.ValueSpec)
g := &Global{
Pkg: pkg,
name: name,
object: obj,
typ: types.NewPointer(obj.Type()), // address
pos: obj.Pos(),
spec: spec,
}
pkg.values[obj] = g
pkg.Members[name] = g
case *types.Func:
var fs *funcSyntax
synthetic := "loaded from gc object file"
if decl, ok := syntax.(*ast.FuncDecl); ok {
synthetic = ""
fs = &funcSyntax{
functype: decl.Type,
recvField: decl.Recv,
body: decl.Body,
}
}
fn := &Function{
name: name,
object: obj,
Signature: obj.Type().(*types.Signature),
Synthetic: synthetic,
pos: obj.Pos(), // (iff syntax)
Pkg: pkg,
Prog: pkg.Prog,
syntax: fs,
}
pkg.values[obj] = fn
if fn.Signature.Recv() == nil {
pkg.Members[name] = fn // package-level function
}
default: // (incl. *types.Package)
panic("unexpected Object type: " + obj.String())
}
}
// memberFromObject populates package pkg with a member for the
// typechecker object obj.
//
// For objects from Go source code, syntax is the associated syntax
// tree (for funcs and vars only); it will be used during the build
// phase.
//
func memberFromObject(pkg *Package, obj types.Object, syntax ast.Node) {
name := obj.Name()
switch obj := obj.(type) {
case *types.TypeName:
pkg.values[obj] = nil // for needMethods
pkg.Members[name] = &Type{
object: obj,
pkg: pkg,
}
case *types.Const:
c := &NamedConst{
object: obj,
Value: NewConst(obj.Val(), obj.Type()),
pkg: pkg,
}
pkg.values[obj] = c.Value
pkg.Members[name] = c
case *types.Var:
g := &Global{
Pkg: pkg,
name: name,
object: obj,
typ: types.NewPointer(obj.Type()), // address
pos: obj.Pos(),
}
pkg.values[obj] = g
pkg.Members[name] = g
case *types.Func:
fn := &Function{
name: name,
object: obj,
Signature: obj.Type().(*types.Signature),
syntax: syntax,
pos: obj.Pos(), // (iff syntax)
Pkg: pkg,
Prog: pkg.Prog,
}
if syntax == nil {
fn.Synthetic = "loaded from gc object file"
}
pkg.values[obj] = fn
if fn.Signature.Recv() == nil {
pkg.Members[name] = fn // package-level function
}
default: // (incl. *types.Package)
panic("unexpected Object type: " + obj.String())
}
}
func (w *Walker) emitObj(obj types.Object) {
switch obj := obj.(type) {
case *types.Const:
w.emitf("const %s %s", obj.Name(), w.typeString(obj.Type()))
w.emitf("const %s = %s", obj.Name(), obj.Val())
case *types.Var:
w.emitf("var %s %s", obj.Name(), w.typeString(obj.Type()))
case *types.TypeName:
w.emitType(obj)
case *types.Func:
w.emitFunc(obj)
default:
panic("unknown object: " + obj.String())
}
}
func (w *PkgWalker) LookupObjects(pkg *types.Package, pkgInfo *types.Info, cursor *FileCursor) {
var cursorObj types.Object
var cursorSelection *types.Selection
var cursorObjIsDef bool
//lookup defs
_ = cursorObjIsDef
if cursorObj == nil {
for sel, obj := range pkgInfo.Selections {
if cursor.pos >= sel.Sel.Pos() && cursor.pos <= sel.Sel.End() {
cursorObj = obj.Obj()
cursorSelection = obj
break
}
}
}
if cursorObj == nil {
for id, obj := range pkgInfo.Defs {
if cursor.pos >= id.Pos() && cursor.pos <= id.End() {
cursorObj = obj
cursorObjIsDef = true
break
}
}
}
_ = cursorSelection
if cursorObj == nil {
for id, obj := range pkgInfo.Uses {
if cursor.pos >= id.Pos() && cursor.pos <= id.End() {
cursorObj = obj
break
}
}
}
if cursorObj == nil {
return
}
kind, err := parserObjKind(cursorObj)
if err != nil {
log.Fatalln(err)
}
if kind == ObjField {
if cursorObj.(*types.Var).Anonymous() {
if named, ok := cursorObj.Type().(*types.Named); ok {
cursorObj = named.Obj()
}
}
}
cursorPkg := cursorObj.Pkg()
cursorPos := cursorObj.Pos()
var fieldTypeInfo *types.Info
var fieldTypeObj types.Object
if cursorPkg == pkg {
fieldTypeInfo = pkgInfo
}
cursorIsInterfaceMethod := false
var cursorInterfaceTypeName string
if kind == ObjMethod && cursorSelection != nil && cursorSelection.Recv() != nil {
sig := cursorObj.(*types.Func).Type().Underlying().(*types.Signature)
if _, ok := sig.Recv().Type().Underlying().(*types.Interface); ok {
named := cursorSelection.Recv().(*types.Named)
obj, typ := w.lookupNamedMethod(named, cursorObj.Name())
if obj != nil {
cursorObj = obj
}
if typ != nil {
cursorPkg = typ.Obj().Pkg()
cursorInterfaceTypeName = typ.Obj().Name()
}
cursorIsInterfaceMethod = true
}
}
if cursorPkg != nil && cursorPkg != pkg &&
kind != ObjPkgName && w.isBinaryPkg(cursorPkg.Path()) {
conf := &PkgConfig{
IgnoreFuncBodies: true,
AllowBinary: true,
Info: &types.Info{
Defs: make(map[*ast.Ident]types.Object),
},
}
pkg, _ := w.Import("", cursorPkg.Path(), conf)
if pkg != nil {
if cursorIsInterfaceMethod {
for _, obj := range conf.Info.Defs {
if obj == nil {
continue
}
if fn, ok := obj.(*types.Func); ok {
if fn.Name() == cursorObj.Name() {
if sig, ok := fn.Type().Underlying().(*types.Signature); ok {
if named, ok := sig.Recv().Type().(*types.Named); ok {
if named.Obj() != nil && named.Obj().Name() == cursorInterfaceTypeName {
cursorPos = obj.Pos()
break
}
}
}
}
}
}
} else {
for _, obj := range conf.Info.Defs {
if obj != nil && obj.String() == cursorObj.String() {
cursorPos = obj.Pos()
break
}
}
}
}
if kind == ObjField || cursorIsInterfaceMethod {
fieldTypeInfo = conf.Info
}
}
if kind == ObjField {
fieldTypeObj = w.LookupStructFromField(fieldTypeInfo, cursorPkg, cursorObj, cursorPos)
}
if typeFindDef {
fmt.Println(w.fset.Position(cursorPos))
}
if typeFindInfo {
if kind == ObjField && fieldTypeObj != nil {
typeName := fieldTypeObj.Name()
if fieldTypeObj.Pkg() != nil && fieldTypeObj.Pkg() != pkg {
typeName = fieldTypeObj.Pkg().Name() + "." + fieldTypeObj.Name()
}
fmt.Println(typeName, simpleType(cursorObj.String()))
} else if kind == ObjBuiltin {
fmt.Println(builtinInfo(cursorObj.Name()))
} else if cursorIsInterfaceMethod {
fmt.Println(strings.Replace(simpleType(cursorObj.String()), "(interface)", cursorPkg.Name()+"."+cursorInterfaceTypeName, 1))
} else {
fmt.Println(simpleType(cursorObj.String()))
}
}
//if f, ok := w.parsedFileCache[w.fset.Position(cursorPos).Filename]; ok {
// for _, d := range f.Decls {
// if inRange(d, cursorPos) {
// if fd, ok := d.(*ast.FuncDecl); ok {
// fd.Body = nil
// }
// commentMap := ast.NewCommentMap(w.fset, f, f.Comments)
// commentedNode := printer.CommentedNode{Node: d}
// if comments := commentMap.Filter(d).Comments(); comments != nil {
// commentedNode.Comments = comments
// }
// var b bytes.Buffer
// printer.Fprint(&b, w.fset, &commentedNode)
// b.Write([]byte("\n\n")) // Add a blank line between entries if we print documentation.
// log.Println(w.nodeString(d))
// }
// }
//}
if !typeFindUse {
return
}
var usages []int
if kind == ObjPkgName {
for id, obj := range pkgInfo.Uses {
if obj != nil && obj.Id() == cursorObj.Id() { //!= nil && cursorObj.Pos() == obj.Pos() {
usages = append(usages, int(id.Pos()))
}
}
} else {
for id, obj := range pkgInfo.Defs {
if obj == cursorObj { //!= nil && cursorObj.Pos() == obj.Pos() {
usages = append(usages, int(id.Pos()))
}
}
for id, obj := range pkgInfo.Uses {
if obj == cursorObj { //!= nil && cursorObj.Pos() == obj.Pos() {
usages = append(usages, int(id.Pos()))
}
}
}
(sort.IntSlice(usages)).Sort()
for _, pos := range usages {
fmt.Println(w.fset.Position(token.Pos(pos)))
}
}
