17

我正在尝试使用 Go 的解析器和ast包读取结构类型的相关文档注释。在此示例中，代码仅将自身用作源。

package main

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

// FirstType docs
type FirstType struct {
    // FirstMember docs
    FirstMember string
}

// SecondType docs
type SecondType struct {
    // SecondMember docs
    SecondMember string
}

// Main docs
func main() {
    fset := token.NewFileSet() // positions are relative to fset

    d, err := parser.ParseDir(fset, "./", nil, parser.ParseComments)
    if err != nil {
        fmt.Println(err)
        return
    }

    for _, f := range d {
        ast.Inspect(f, func(n ast.Node) bool {
            switch x := n.(type) {
            case *ast.FuncDecl:
                fmt.Printf("%s:\tFuncDecl %s\t%s\n", fset.Position(n.Pos()), x.Name, x.Doc)
            case *ast.TypeSpec:
                fmt.Printf("%s:\tTypeSpec %s\t%s\n", fset.Position(n.Pos()), x.Name, x.Doc)
            case *ast.Field:
                fmt.Printf("%s:\tField %s\t%s\n", fset.Position(n.Pos()), x.Names, x.Doc)
            }

            return true
        })
    }
}

func 和 fields 的注释文档输出没有问题，但由于某种原因，找不到“FirstType docs”和“SecondType docs”。我错过了什么？Go 版本是 1.1.2。

（要运行上述程序，请将其保存到 main.go 文件中，然后go run main.go）

4

3 回答 3

19

好问题！

查看 的源代码go/doc，我们可以看到它必须在readType函数中处理相同的情况。在那里，它说：

324     func (r *reader) readType(decl *ast.GenDecl, spec *ast.TypeSpec) {
...
334     // compute documentation
335     doc := spec.Doc
336     spec.Doc = nil // doc consumed - remove from AST
337     if doc == nil {
338         // no doc associated with the spec, use the declaration doc, if any
339         doc = decl.Doc
340     }
...

特别注意它需要如何处理 AST 没有附加到 TypeSpec 的文档的情况。为此，它依赖于GenDecl. 这为我们提供了关于如何直接使用 AST 来解析结构的文档注释的线索。调整问题代码中的 for 循环以添加案例 for *ast.GenDecl：

for _, f := range d {
    ast.Inspect(f, func(n ast.Node) bool {
        switch x := n.(type) {
        case *ast.FuncDecl:
            fmt.Printf("%s:\tFuncDecl %s\t%s\n", fset.Position(n.Pos()), x.Name, x.Doc.Text())
        case *ast.TypeSpec:
            fmt.Printf("%s:\tTypeSpec %s\t%s\n", fset.Position(n.Pos()), x.Name, x.Doc.Text())
        case *ast.Field:
            fmt.Printf("%s:\tField %s\t%s\n", fset.Position(n.Pos()), x.Names, x.Doc.Text())
        case *ast.GenDecl:
            fmt.Printf("%s:\tGenDecl %s\n", fset.Position(n.Pos()), x.Doc.Text())
        }

        return true
    })
}

运行这个给我们：

main.go:3:1:    GenDecl %!s(*ast.CommentGroup=<nil>)
main.go:11:1:   GenDecl &{[%!s(*ast.Comment=&{69 // FirstType docs})]}
main.go:11:6:   TypeSpec FirstType  %!s(*ast.CommentGroup=<nil>)
main.go:13:2:   Field [FirstMember] &{[%!s(*ast.Comment=&{112 // FirstMember docs})]}
main.go:17:1:   GenDecl &{[%!s(*ast.Comment=&{155 // SecondType docs})]}
main.go:17:6:   TypeSpec SecondType %!s(*ast.CommentGroup=<nil>)
main.go:19:2:   Field [SecondMember]    &{[%!s(*ast.Comment=&{200 // SecondMember docs})]}
main.go:23:1:   FuncDecl main   &{[%!s(*ast.Comment=&{245 // Main docs})]}
main.go:33:23:  Field [n]   %!s(*ast.CommentGroup=<nil>)
main.go:33:35:  Field []    %!s(*ast.CommentGroup=<nil>)

而且，嘿！

我们已经打印出了久违的FirstType docs和SecondType docs！但这并不令人满意。为什么文档没有附加到TypeSpec? 如果没有与结构声明相关的文档，该go/doc/reader.go文件会非常长地规避这个问题，实际上会生成一个假文件GenDecl并将其传递给前面提到的函数！readType

   503  fake := &ast.GenDecl{
   504   Doc: d.Doc,
   505   // don't use the existing TokPos because it
   506   // will lead to the wrong selection range for
   507   // the fake declaration if there are more
   508   // than one type in the group (this affects
   509   // src/cmd/godoc/godoc.go's posLink_urlFunc)
   510   TokPos: s.Pos(),
   511   Tok:    token.TYPE,
   512   Specs:  []ast.Spec{s},
   513  }

但为什么这一切？

想象一下，我们稍微改变了问题中代码的类型定义（定义这样的结构并不常见，但仍然有效的 Go）：

// This documents FirstType and SecondType together
type (
    // FirstType docs
    FirstType struct {
        // FirstMember docs
        FirstMember string
    }

    // SecondType docs
    SecondType struct {
        // SecondMember docs
        SecondMember string
    }
)

运行代码（包括 的情况ast.GenDecl），我们得到：

main.go:3:1:    GenDecl %!s(*ast.CommentGroup=<nil>)
main.go:11:1:   GenDecl &{[%!s(*ast.Comment=&{69 // This documents FirstType and SecondType together})]}
main.go:13:2:   TypeSpec FirstType  &{[%!s(*ast.Comment=&{129 // FirstType docs})]}
main.go:15:3:   Field [FirstMember] &{[%!s(*ast.Comment=&{169 // FirstMember docs})]}
main.go:19:2:   TypeSpec SecondType &{[%!s(*ast.Comment=&{215 // SecondType docs})]}
main.go:21:3:   Field [SecondMember]    &{[%!s(*ast.Comment=&{257 // SecondMember docs})]}
main.go:26:1:   FuncDecl main   &{[%!s(*ast.Comment=&{306 // Main docs})]}
main.go:36:23:  Field [n]   %!s(*ast.CommentGroup=<nil>)
main.go:36:35:  Field []    %!s(*ast.CommentGroup=<nil>)

这是正确的

现在结构类型定义有自己的文档，也GenDecl有自己的文档。在第一种情况下，发布在问题中，文档附加到GenDecl，因为 AST 看到类型定义的括号版本的“收缩”的单个结构类型定义，并且希望处理所有定义相同，无论它们是分组与否。变量定义也会发生同样的事情，如下所示：

// some general docs
var (
    // v docs
    v int

    // v2 docs
    v2 string
)

所以如果你想用纯 AST 解析评论，你需要知道它是这样工作的。但正如@mjibson 建议的那样，首选方法是使用go/doc. 祝你好运！

于 2016-02-18T16:36:47.967 回答
10

您需要使用该go/doc包从 ast 中提取文档：

package main

import (
    "fmt"
    "go/doc"
    "go/parser"
    "go/token"
)

// FirstType docs
type FirstType struct {
    // FirstMember docs
    FirstMember string
}

// SecondType docs
type SecondType struct {
    // SecondMember docs
    SecondMember string
}

// Main docs
func main() {
    fset := token.NewFileSet() // positions are relative to fset

    d, err := parser.ParseDir(fset, "./", nil, parser.ParseComments)
    if err != nil {
        fmt.Println(err)
        return
    }

    for k, f := range d {
        fmt.Println("package", k)
        p := doc.New(f, "./", 0)

        for _, t := range p.Types {
            fmt.Println("  type", t.Name)
            fmt.Println("    docs:", t.Doc)
        }
    }
}
于 2013-10-25T03:50:55.123 回答
0

用注释解析所有结构 // typescript:interface

func TestStructDoc(t *testing.T) {
err := filepath.Walk(".",
    func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if info.IsDir() {
            fmt.Println(path, info.Size())
            fset := token.NewFileSet()
            d, err := parser.ParseDir(fset, path, nil, parser.ParseComments)
            if err != nil {
                t.Fatal(err)

            }

            for k, f := range d {
                fmt.Println("package", k)
                p := doc.New(f, "./", 0)

                for _, t := range p.Types {
                    fmt.Println("  type", t.Name)
                    fmt.Println("    docs:", t.Doc)
                    if strings.HasPrefix(t.Doc, "typescript:interface") {

                        for _, spec := range t.Decl.Specs {
                            switch spec.(type) {
                            case *ast.TypeSpec:
                                typeSpec := spec.(*ast.TypeSpec)

                                fmt.Printf("Struct: name=%s\n", typeSpec.Name.Name)

                                switch typeSpec.Type.(type) {
                                case *ast.StructType:
                                    structType := typeSpec.Type.(*ast.StructType)
                                    for _, field := range structType.Fields.List {
                                        i := field.Type.(*ast.Ident)
                                        fieldType := i.Name

                                        for _, name := range field.Names {
                                            fmt.Printf("\tField: name=%s type=%s\n", name.Name, fieldType)
                                        }

                                    }

                                }
                            }
                        }
                    }

                }
            }
        }
        return nil
    })
if err != nil {
    t.Fatal(err)
}

}

于 2022-01-24T12:18:37.780 回答