如何从golang抽象语法树中，提取有多少结构体实现了某个接口

要从Go语言的抽象语法树中提取实现了某个接口的结构体，可以按照以下步骤进行：

1. 使用Go语言自带的"go/ast"包，将Go代码解析为抽象语法树。

2. 遍历抽象语法树，找到所有的结构体定义。

3. 对于每个结构体定义，遍历其所有的方法，判断其中是否有实现了目标接口的方法，若有则将该结构体记录下来。

4. 统计所有记录的结构体，即可得到实现了目标接口的结构体数量。

下面是一个简单的示例代码，用于提取实现了"io.Reader"接口的结构体数量：

package main

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

func main() {
    // 读取Go代码文件
    fset := token.NewFileSet()
    f, err := parser.ParseFile(fset, "example.go", nil, 0)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 遍历抽象语法树，查找实现了"io.Reader"接口的结构体
    count := 0
    ast.Inspect(f, func(node ast.Node) bool {
        switch n := node.(type) {
        case *ast.InterfaceType:
            // 找到目标接口
            if isIoReader(n) {
                // 遍历所有结构体定义
                for _, d := range f.Decls {
                    if gd, ok := d.(*ast.GenDecl); ok && gd.Tok == token.TYPE {
                        for _, spec := range gd.Specs {
                            if ts, ok := spec.(*ast.TypeSpec); ok {
                                if st, ok := ts.Type.(*ast.StructType); ok {
                                    // 遍历结构体的所有方法，查找是否有实现了目标接口的方法
                                    for _, f := range st.Fields.List {
                                        if len(f.Names) > 0 {
                                            name := f.Names[0]
                                            if isIoReaderMethod(f.Type, name.Name) {
                                                count++
                                                fmt.Println("Found struct implementing io.Reader:", ts.Name.Name)
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return true
    })

    fmt.Println("Total number of structs implementing io.Reader:", count)
}

// 判断一个类型是否是"io.Reader"接口类型
func isIoReader(t ast.Expr) bool {
    if ident, ok := t.(*ast.Ident); ok {
        if ident.Name == "Reader" && ident.Obj == nil {
            if sel, ok := ident.X.(*ast.SelectorExpr); ok {
                if pkg, ok := sel.X.(*ast.Ident); ok {
                    if pkg.Name == "io" && pkg.Obj == nil {
                        return true
                    }
                }
            }
        }
    }
    return false
}

// 判断一个结构体方法是否实现了"io.Reader"接口的方法
func isIoReaderMethod(t ast.Expr, name string) bool {
    if sel, ok := t.(*ast.SelectorExpr); ok {
        if ident, ok := sel.X.(*ast.Ident); ok {
            if ident.Name == "io" {
                if sel.Sel.Name == "Read" && name == "Read" {
                    return true
                }
            }
        }
    }
    return false
}

在上面的示例代码中，我们使用了"go/ast"包中的"Inspect"函数来遍历抽象语法树。在遍历过程中，我们首先找到了目标接口"io.Reader"，然后遍历所有的结构体定义，查找其中是否有实现了目标接口的方法。如果找到了这样的结构体，就将其记录下来，并最终统计所有记录的结构体数量。