go-aster

一个对官方库的二次封装的 Go AST 解析库，提供更简单直观的静态类型分析功能，支持泛型、结构体、接口、函数等完整的 Go 语言特性解析。

🌟 特性

• 完整的 AST 解析：支持解析 Go 语言的所有核心特性
• 泛型支持：完整支持 Go 1.18+ 的泛型语法
• 类型推断：提供类似 reflect.Type 的静态类型接口
• 注释解析：保留和处理代码注释信息
• 标签解析：完整支持 struct tag 解析
• 方法关联：自动将方法关联到对应的结构体
• 导入管理：智能处理包导入和别名

📦 安装

go get -u github.com/szyhf/go-aster

🚀 快速开始

基本用法

package main

import (
    "fmt"
    "log"

    aster "github.com/szyhf/go-aster"
)

func main() {
    // 解析整个目录
    packages, err := aster.ParseDir("./your-go-project", nil)
    if err != nil {
        log.Fatal(err)
    }

    // 输出解析结果
    for _, pkg := range packages {
        fmt.Printf("Package: %s\n", pkg.Name)
        fmt.Printf("Structs: %d\n", len(pkg.Structs))
        fmt.Printf("Interfaces: %d\n", len(pkg.Interfaces))
        fmt.Printf("Functions: %d\n", len(pkg.Funcs))
    }
}

解析单个文件

package, err := aster.ParseFile("./models/user.go")
if err != nil {
    log.Fatal(err)
}

fmt.Println(package.String())

🔍 核心功能

包解析

go-aster 可以解析 Go 包的所有核心组件：

type PackageType struct {
    Name       string           // 包名
    Imports    []*ImportType    // 导入的包
    Interfaces []*InterfaceType // 接口定义
    Structs    []*StructType    // 结构体定义
    Funcs      []*FuncType      // 包级函数
    Methods    []*MethodType    // 方法定义
}

结构体解析

支持泛型结构体和字段信息解析：

type LikeGeneric[K comparable, V any] struct {
    ID     int64              `json:"id"`
    User   *UserGeneric[K, V] `json:"user"`
    Status string             `json:"status"`
}

func (l *LikeGeneric[K, V]) TableName() string {
    return "like_generic"
}

解析后的结构体信息包含：

• 泛型参数 (TypeParams)
• 字段信息 (Fields)
• 关联方法 (Methods)
• 文档注释 (Docs)

接口解析

完整支持接口定义解析：

type Reader interface {
    Read(p []byte) (n int, err error)
    Close() error
}

类型系统

提供了类似 reflect.Type 的静态类型接口：

type Type interface {
    Name() string
    Kind() Kind
    Elem() Type
    Field(i int) StructFieldType
    Method(i int) MethodType
    // ... 更多方法
}

支持的类型包括：

• 基本类型 (Ident)
• 结构体 (Struct)
• 接口 (Interface)
• 数组/切片 (Array)
• 映射 (Map)
• 通道 (Chan)
• 函数 (Func)
• 指针 (Star)

📖 使用示例

遍历结构体字段

for _, pkg := range packages {
    for _, structType := range pkg.Structs {
        fmt.Printf("Struct: %s\n", structType.GetDeclName())

        for _, field := range structType.Fields {
            fmt.Printf("  %s: %s\n", field.Name, field.Type.GetDecl())

            // 访问 struct tag
            if field.Tag != "" {
                fmt.Printf("    Tag: %s\n", field.Tag)
            }
        }

        // 遍历方法
        for _, method := range structType.Methods {
            fmt.Printf("  Method: %s%s\n", method.Name, method.Type.GetDecl())
        }
    }
}

解析函数签名

for _, pkg := range packages {
    for _, fn := range pkg.Funcs {
        fmt.Printf("Function: %s%s\n", fn.Name, fn.Type.GetDecl())

        // 参数信息
        for i := 0; i < fn.Type.NumIn(); i++ {
            param := fn.Type.In(i)
            fmt.Printf("  Arg[%d]: %s\n", i, param.GetDecl())
        }

        // 返回值信息
        for i := 0; i < fn.Type.NumOut(); i++ {
            ret := fn.Type.Out(i)
            fmt.Printf("  Return[%d]: %s\n", i, ret.GetDecl())
        }
    }
}

处理导入信息

for _, pkg := range packages {
    fmt.Printf("Package: %s\n", pkg.Name)

    for _, imp := range pkg.Imports {
        if imp.Alias != "" {
            fmt.Printf("  Import: %s -> %s\n", imp.Alias, imp.Name)
        } else {
            fmt.Printf("  Import: %s\n", imp.Name)
        }
    }
}

🛠️ 高级用法

自定义文件过滤器

// 只解析 .go 文件，忽略测试文件
filter := func(info os.FileInfo) bool {
    return !strings.HasSuffix(info.Name(), "_test.go")
}

packages, err := aster.ParseDir("./src", filter)

代码生成

go-aster 非常适合用于代码生成场景，例如：

• ORM 代码生成
• API 文档生成
• 序列化/反序列化代码生成
• 类型转换工具生成
• 依赖注入框架

静态分析

可用于构建各种静态分析工具：

• 代码质量检查
• 依赖关系分析
• API 兼容性检查
• 死代码检测

🧪 测试

运行测试用例：

go test ./...

查看测试示例了解更多的使用方式。

🤝 贡献

欢迎提交 Issue 和 Pull Request！

📄 许可证

BSD 3-Clause License

🔗 相关项目

• go/ast - Go 标准库 AST 包
• go/parser - Go 源码解析器

---

注意: 这个库已经在生产环境中使用多年，功能稳定，但仍在持续改进中。如果您遇到任何问题或有功能建议，欢迎提交 Issue。