parsing - 如何使用 Go 解析方法或函数中的语句

Question

我想解析 go 代码，尤其是函数的内容。

到目前为止，使用 parser.ParseFile 函数很容易获得函数声明。

package main

import (
    "fmt"
    "go/parser"
    "go/token"
    "go/ast"
    "log"
)

var code = []byte(`
package main

import (
    "fmt"
)

func GetFoo() {
    test := foo()
    fmt.Println(test)
}

func foo() int {
    return 0
}
`)

func main() {
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "", code, parser.ParseComments)
    if err != nil {
        log.Fatal(err)
    }

    for _, decl := range f.Decls {
        switch t := decl.(type) {
        // That's a func decl !
        case *ast.FuncDecl:
            fmt.Printf("Function name: %v\n", t.Name)
            // Now I would like to access to the test var and get its type
            // Must be int, because foo() returns an int
        }
    }

}

现在我想访问 test var 并获取它的类型，但我有点迷路了。我已经看到 decl.Body.List 迭代语句，但我可以得到我的 test var 是一个 int

感谢您宝贵的帮助!

https://play.golang.org/p/Y8uwM-CDWy

Answer 1

感谢JimB以及他关于 go/types 的提示，这是我如何获得我的方法的签名

package main

import (
    "fmt"
    "go/ast"
    "go/importer"
    "go/parser"
    "go/token"
    "go/types"
    "log"
)

var code = []byte(`
package main

import (
    "fmt"
)

func GetFoo() {
    test := foo()
    fmt.Println(test)
}

func foo() int {
    return 0
}
`)

func main() {
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "", code, parser.ParseComments)
    if err != nil {
        log.Fatal(err)
    }

    conf := types.Config{Importer: importer.Default()}
    pkg, err := conf.Check("cmd", fset, []*ast.File{f}, nil)
    scope := pkg.Scope()

    for _, decl := range f.Decls {
        switch t := decl.(type) {
        // That's a func decl !
        case *ast.FuncDecl:
            for _, s := range t.Body.List {
                switch as := s.(type) {
                case *ast.AssignStmt:
                    for _, l := range as.Rhs {
                        switch rh := l.(type) {
                        case *ast.CallExpr:
                            if i, ok := rh.Fun.(*ast.Ident); ok {
                                ft := scope.Lookup(i.Name)
                                if ft != nil {
                                    if ftype, ok := ft.(*types.Func); ok {
                                        f := ftype.Type()
                                        if sig, ok := f.(*types.Signature); ok {
                                            // get the returned elements
                                            r := sig.Results()
                                            for i := 0; i < r.Len(); i++ {
                                                v := r.At(i)
                                                varTpe := v.Type()
                                                fmt.Println(varTpe)
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}