当前位置：首页 > 文章列表 > Golang > Go问答 > 通过使用 go ast 检索函数名称周围的位置信息

通过使用 go ast 检索函数名称周围的位置信息

来源：stackoverflow 2024-02-08 19:36:22 0浏览收藏

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《通过使用 go ast 检索函数名称周围的位置信息》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

问题内容

仅通过源代码（无需运行时检查）从文件位置获取周围函数名称的最佳方法是什么？

例如，假设我有一些代码：

func MyFunc() {
    doSomething() // package/file.go:215:15
}

而我有dosomething的位置，在package/file.go:215:15，有没有办法轻松获取myfunc？

正确答案

包含“最好”一词的问题总是很难回答，因为这很大程度上取决于您的要求，而您尚未指出这些要求。

我想了两种方法来解决这个问题，都有自己的优点和缺点：

快速而肮脏

快速而肮脏的方法是循环遍历每一行代码，并在我们到达感兴趣的行之前查找最近出现的函数减速。哪个应该是包含我们的行的函数。 p>

package main

import (
    "bufio"
    "fmt"
    "os"
    "regexp"
    "strconv"
    "strings"
)

func main() {
    if len(os.args) < 2 {
        usage()
    }

    loc := strings.split(os.args[1], ":")
    if len(loc) != 2 {
        usage()
    }

    filepath := loc[0]
    linestr := loc[1]
    targetline, err := strconv.atoi(linestr)
    if err != nil {
        fmt.println(err.error())
        usage()
    }

    f, err := os.open(filepath)
    if err != nil {
        fmt.println(err.error())
        usage()
    }
    defer f.close()

    linescanner := bufio.newscanner(f)
    line := 0
    var lastfunc string
    for linescanner.scan() {
        m := funcname.findstringsubmatch(linescanner.text())
        if len(m) > 0 {
            lastfunc = m[1]
        }

        if line == targetline {
            fmt.println(lastfunc)
            return
        }

        line++
    }
}

func usage() {
    fmt.fprintf(os.stderr, "usage: %s {file:line}\n", os.args[0])
    os.exit(1)
}

// look for a func followed by anything and ending at a `(` or ` `(space).
var funcname = regexp.mustcompile(`func ([^ (]+)`)

优点：

快速（相对于构建 ast）
易于理解（无需了解 ast 和深度优先搜索的工作原理）
当 go 代码包含解析器失败的错误时有效（这可能是您想要的某些类型的 linter 或工具）。

缺点：

关于代码的假设，我们假设 （ 和是唯一结束 func 声明的字符，并且我们假设代码经过格式化，以便在 1 行上永远不会出现 2 个 func 声明。

解析、ast、深度优先搜索

更“规范正确”的方法是使用 go 编译器也使用的“官方”go parser 来解析 go 代码。这会产生一个 ast（抽象语法树），我们可以使用 dfs（深度优先搜索）算法遍历它，以找到包含我们位置的最具体的 ast 节点，同时还可以找到最新的函数减速。

package main

import (
    "fmt"
    "go/ast"
    "go/parser"
    "go/token"
    "os"
    "regexp"
    "strconv"
    "strings"
)

func main() {
    if len(os.Args) < 2 {
        usage()
    }

    var pos token.Position

    loc := strings.Split(os.Args[1], ":")
    if len(loc) >= 2 {
        pos.Filename = loc[0]
        line, err := strconv.Atoi(loc[1])
        if err != nil {
            fmt.Println(err.Error())
            usage()
        }
        pos.Line = line
    } else {
        usage()
    }

    if len(loc) >= 3 {
        col, err := strconv.Atoi(loc[2])
        if err != nil {
            fmt.Println(err.Error())
            usage()
        }
        pos.Column = col
    }

    file, err := os.Open(pos.Filename)
    if err != nil {
        fmt.Println(err.Error())
        usage()
    }

    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "", file, 0)
    if err != nil {
        fmt.Println(err.Error())
        usage()
    }

    var lastFunc *ast.FuncDecl
    ast.Inspect(f, func(n ast.Node) bool {
        if n == nil {
            return false
        }

        // Store the most specific function declaration
        if funcDecl, ok := n.(*ast.FuncDecl); ok {
            lastFunc = funcDecl
        }

        start := fset.Position(n.Pos())
        end := fset.Position(n.End())

        // Don't traverse nodes which don't contain the target line
        if start.Line > pos.Line || end.Line < pos.Line {
            return false
        }

        // If node starts and stops on the same line
        if start.Line == pos.Line && end.Line == pos.Line {
            // Don't traverse nodes which don't contain the target column
            if start.Column > pos.Column || end.Column < pos.Column {
                return false
            }
        }

        // Note, the very last node to be traversed is our target node

        return true
    })

    if lastFunc != nil {
        fmt.Println(lastFunc.Name.String())
    }
}

func usage() {
    fmt.Fprintf(os.Stderr, "Usage: %s {file:line:column}\n", os.Args[0])
    os.Exit(1)
}

优点：