Go 怎么解析源码并列出函数名和参数

如果要给 Go 项目生成 API 索引、检查函数命名，或做一个轻量的代码导航工具，不必先把源码当成普通文本用正则切分。更稳妥的做法是用 go/parser 生成 AST，再从 *ast.FuncDecl 读取名称和参数字段。下面的程序接收一个 Go 文件路径，输出普通函数、方法、参数签名和声明行号。

核心关系是：parser.ParseFile 负责把源码变成 *ast.File，ast.Inspect 找到 *ast.FuncDecl，FuncDecl.Type.Params.List 保存参数字段；类型本身再交给 format.Node 还原。

先把源码变成可遍历的 AST

parser.ParseFile 可以从文件名读取源码，也可以接收字符串、字节切片或 io.Reader。这里直接传文件路径，第四个参数使用 parser.SkipObjectResolution，因为我们只关心语法树，不需要已经废弃的标识符对象解析。

FileSet 不只是形式参数，它记录文件和位置之间的映射。后面通过 fset.Position(decl.Pos()).Line 取得函数声明所在行。

从 FuncDecl 读取函数名与方法接收者

顶层函数和方法都会表示为 *ast.FuncDecl。名称从 Name.Name 读取；如果 Recv != nil，说明当前声明是方法，可以再把接收者类型格式化出来。使用 ast.Inspect 的好处是遍历逻辑清楚，并且不会把普通标识符误当函数名。

下面的完整示例只输出声明节点，不解析函数体里的函数调用，因此结果表示“这个文件声明了哪些函数”，不是“这些函数运行时调用了谁”。

package main

import (
    "bytes"
    "fmt"
    "go/ast"
    "go/format"
    "go/parser"
    "go/token"
    "os"
    "strings"
)

// formatExpr 把 AST 类型节点还原成读者能直接阅读的 Go 类型文本。
func formatExpr(fset *token.FileSet, expr ast.Expr) string {
    var buf bytes.Buffer
    if err := format.Node(&buf, fset, expr); err != nil {
        return ""
    }
    return buf.String()
}

// formatParams 展开参数字段，兼容 a, b int 这种共享类型的写法。
func formatParams(fset *token.FileSet, fields *ast.FieldList) []string {
    if fields == nil {
        return nil
    }
    params := make([]string, 0, fields.NumFields())
    for _, field := range fields.List {
        typ := formatExpr(fset, field.Type)
        if len(field.Names) == 0 {
            // 只有类型时，保留无名参数的真实类型。
            params = append(params, typ)
            continue
        }
        for _, name := range field.Names {
            // 一个 Field 可能对应多个同类型名称，因此要逐名输出。
            params = append(params, name.Name+" "+typ)
        }
    }
    return params
}

func main() {
    if len(os.Args) != 2 {
        fmt.Fprintln(os.Stderr, "用法：go run main.go path/to/file.go")
        os.Exit(2)
    }

    filename := os.Args[1]
    fset := token.NewFileSet()
    file, err := parser.ParseFile(fset, filename, nil, parser.SkipObjectResolution)
    if err != nil {
        // 读取失败和语法错误都应直接返回，避免输出不完整索引。
        fmt.Fprintf(os.Stderr, "解析失败：%v\n", err)
        os.Exit(1)
    }

    ast.Inspect(file, func(node ast.Node) bool {
        decl, ok := node.(*ast.FuncDecl)
        if !ok {
            return true
        }

        kind := "函数"
        receiver := ""
        if decl.Recv != nil && decl.Recv.NumFields() > 0 {
            kind = "方法"
            receiver = formatExpr(fset, decl.Recv.List[0].Type)
        }
        params := strings.Join(formatParams(fset, decl.Type.Params), ", ")
        line := fset.Position(decl.Pos()).Line
        if receiver != "" {
            fmt.Printf("%s %s.%s(%s) - 第%d行\n", kind, receiver, decl.Name.Name, params, line)
        } else {
            fmt.Printf("%s %s(%s) - 第%d行\n", kind, decl.Name.Name, params, line)
        }
        return true
    })
}

把参数字段还原成可读签名

参数列表的关键是 ast.FieldList。每个 Field 有一个类型和零个或多个名称，因此不能写成“取 field.Names[0]”的固定逻辑。对于 func Open(path string, mode ...int)，可得到 path string 与 mode ...int；对于 func Pair(a, b int)，应展开成两个参数。

使用 format.Node 而不是自己拼接类型，能够保留指针、切片、映射、函数类型和可变参数的语法形状。它只负责格式化 AST，不代表做了类型检查；例如别名最终是什么底层类型，必须交给 go/types 或加载包的工具链判断。

用位置和边界检查结果

运行时把待分析文件路径传给程序，例如 go run main.go ./sample.go。正常输出中的行号来自 FileSet，不是通过统计换行符猜出来的。若源文件有语法错误，ParseFile 可能返回部分 AST 和错误；索引工具通常应该像示例一样遇到错误就停止，避免把半截结果当成完整清单。

这个方案适合单文件或只看语法结构的轻量工具。如果需求扩大到整个模块、构建标签、类型推导、跨包引用或方法集分析，应改用 golang.org/x/tools/go/packages 配合 go/types。解析 AST 能回答“声明长什么样”，不能单独回答“这个标识符最终指向哪个定义”。

相关问题

Go AST 里怎么区分函数和方法？

检查 *ast.FuncDecl 的 Recv：普通函数为 nil，方法通常包含接收者字段。名称都从 Name.Name 读取。

为什么参数名称会少于参数数量？

Go 允许多个参数共享一个类型，例如 a, b int 只对应一个 Field。遍历 field.Names 才能展开每个名称；无名参数则应保留类型。

解析 Go 源码一定要做类型检查吗？

不一定。列出声明名称和语法形式只需要 go/parser 与 go/ast；需要跨包引用、别名和实际类型时，才增加加载与类型检查。

官方 API 可继续查看：go/parser、go/ast 与 go/token。