Package ast

func FileExports(src *File) bool

func FilterDecl(decl Decl, f Filter) bool

func FilterFile(src *File, f Filter) bool

func FilterPackage(pkg *Package, f Filter) bool

func Fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) error

func Inspect(node Node, f func(Node) bool)

package main

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

func main() {
	// src是我们要检查AST的输入。
	src := `
package p
const c = 1.0
var X = f(3.14)*2 + c
`

	// 通过解析src来创建AST。
	fset := token.NewFileSet() // 职位相对于fset
	f, err := parser.ParseFile(fset, "src.go", src, 0)
	if err != nil {
		panic(err)
	}

	// 检查AST并打印所有标识符和文字。
	ast.Inspect(f, func(n ast.Node) bool {
		var s string
		switch x := n.(type) {
		case *ast.BasicLit:
			s = x.Value
		case *ast.Ident:
			s = x.Name
		}
		if s != "" {
			fmt.Printf("%s:\t%s\n", fset.Position(n.Pos()), s)
		}
		return true
	})

}

func IsExported(name string) bool

func NotNilFilter(_ string, v reflect.Value) bool

func PackageExports(pkg *Package) bool

func Print(fset *token.FileSet, x interface{}) error

package main

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

func main() {
	// src是我们要打印AST的输入。
	src := `
package main
func main() {
	println("Hello, World!")
}
`

	// 通过解析src来创建AST。
	fset := token.NewFileSet() // 职位相对于fset
	f, err := parser.ParseFile(fset, "", src, 0)
	if err != nil {
		panic(err)
	}

	// 打印AST。
	ast.Print(fset, f)

}

func SortImports(fset *token.FileSet, f *File)

func Walk(v Visitor, node Node)

type ArrayType struct {
        Lbrack token.Pos // “[”的位置
        Len    Expr      // [...] T数组类型的省略号节点，切片类型为零
        Elt    Expr      // 元素类型
}

func (x *ArrayType) End() token.Pos

func (x *ArrayType) Pos() token.Pos

type AssignStmt struct {
        Lhs    []Expr
        TokPos token.Pos   // Tok的位置
        Tok    token.Token // 赋值令牌，DEFINE
        Rhs    []Expr
}

func (s *AssignStmt) End() token.Pos

func (s *AssignStmt) Pos() token.Pos

type BadDecl struct {
        From, To token.Pos // 不良声明的位置范围
}

func (d *BadDecl) End() token.Pos

func (d *BadDecl) Pos() token.Pos

type BadExpr struct {
        From, To token.Pos // 不良表达的位置范围
}

func (x *BadExpr) End() token.Pos

func (x *BadExpr) Pos() token.Pos

type BadStmt struct {
        From, To token.Pos // 不良陈述的位置范围
}

func (s *BadStmt) End() token.Pos

func (s *BadStmt) Pos() token.Pos

type BasicLit struct {
        ValuePos token.Pos   // literal position
        Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
        Value    string      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
}

func (x *BasicLit) End() token.Pos

func (x *BasicLit) Pos() token.Pos

type BinaryExpr struct {
        X     Expr        // 左操作数
        OpPos token.Pos   // Op的位置
        Op    token.Token // 操作者
        Y     Expr        // 右操作数
}

func (x *BinaryExpr) End() token.Pos

func (x *BinaryExpr) Pos() token.Pos

type BlockStmt struct {
        Lbrace token.Pos // “{”的位置
        List   []Stmt
        Rbrace token.Pos // “}”的位置
}

func (s *BlockStmt) End() token.Pos

func (s *BlockStmt) Pos() token.Pos

type BranchStmt struct {
        TokPos token.Pos   // Tok的位置
        Tok    token.Token // 关键字令牌（BREAK，CONTINUE，GOTO，FALLTHROUGH）
        Label  *Ident      // 标签名称; 或者nil
}

func (s *BranchStmt) End() token.Pos

func (s *BranchStmt) Pos() token.Pos

type CallExpr struct {
        Fun      Expr      // 函数表达
        Lparen   token.Pos // “（”的位置
        Args     []Expr    // 函数参数; 或者没有
        Ellipsis token.Pos // “......”的位置（如果没有“......”则为token.NoPos）
        Rparen   token.Pos // “）的位置
}

func (x *CallExpr) End() token.Pos

func (x *CallExpr) Pos() token.Pos

type CaseClause struct {
        Case  token.Pos // “case”或“default”关键字的位置
        List  []Expr    // 表达式或类型列表; nil表示默认情况
        Colon token.Pos // “：”的位置
        Body  []Stmt    // 声明清单; 或者没有
}

func (s *CaseClause) End() token.Pos

func (s *CaseClause) Pos() token.Pos

type ChanDir int

const (
        SEND ChanDir = 1 << iota
        RECV
)

type ChanType struct {
        Begin token.Pos // “chan”关键字或“< - ”的位置（以先到者为准）
        Arrow token.Pos // “< - ”的位置（如果没有“< - ”则为token.NoPos）
        Dir   ChanDir   // 渠道方向
        Value Expr      // 值类型
}

func (x *ChanType) End() token.Pos

func (x *ChanType) Pos() token.Pos

type CommClause struct {
        Case  token.Pos // “case”或“default”关键字的位置
        Comm  Stmt      // 发送或接收声明; nil表示默认情况
        Colon token.Pos // “：”的位置
        Body  []Stmt    // 声明清单; 或者没有
}

func (s *CommClause) End() token.Pos

func (s *CommClause) Pos() token.Pos

type Comment struct {
        Slash token.Pos // “/”开头注释的位置
        Text  string    // 注释文本（不包括用于//style 注释的'\n'）
}

func (c *Comment) End() token.Pos

func (c *Comment) Pos() token.Pos

type CommentGroup struct {
        List []*Comment // len(List) > 0
}

func (g *CommentGroup) End() token.Pos

func (g *CommentGroup) Pos() token.Pos

func (g *CommentGroup) Text() string

type CommentMap map[Node][]*CommentGroup

package main

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

func main() {
	// src是我们创建AST的输入
	// 将要操纵。
	src := `
// This is the package comment.
package main

// This comment is associated with the hello constant.
const hello = "Hello, World!" // line comment 1

// This comment is associated with the foo variable.
var foo = hello // line comment 2 

// This comment is associated with the main function.
func main() {
	fmt.Println(hello) // line comment 3
}
`

	// 通过解析src来创建AST。
	fset := token.NewFileSet() // 职位相对于fset
	f, err := parser.ParseFile(fset, "src.go", src, parser.ParseComments)
	if err != nil {
		panic(err)
	}

	// 从ast.File的注释中创建一个ast.CommentMap。
	// 这有助于保持注释之间的关联
	// 和AST节点。
	cmap := ast.NewCommentMap(fset, f, f.Comments)

	// 从声明列表中删除第一个变量声明。
	for i, decl := range f.Decls {
		if gen, ok := decl.(*ast.GenDecl ok && gen.Tok == token.VAR {
			copy(f.Decls[i:], f.Decls[i+1:])
			f.Decls = f.Decls[:len(f.Decls)-1]
		}
	}

	// 使用注释地图过滤不再属于的注释
	// （与变量声明相关的注释），并创建
	// 新注释列表。
	f.Comments = cmap.Filter(f).Comments()

	// 打印修改后的AST。
	var buf bytes.Buffer
	if err := format.Node(&buf, fset, f err != nil {
		panic(err)
	}
	fmt.Printf("%s", buf.Bytes())

}

func NewCommentMap(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap

 -  g与n结束时在同一行开始
-  g紧跟在n之后的行上开始，并且有
  g之后和下一个节点之前至少有一个空行
-  g在n之前开始，并且不与n之前的节点相关联
  通过以前的规则

func (cmap CommentMap) Comments() []*CommentGroup

func (cmap CommentMap) Filter(node Node) CommentMap

func (cmap CommentMap) String() string

func (cmap CommentMap) Update(old, new Node) Node

type CompositeLit struct {
        Type   Expr      // 字面类型; 或者nil
        Lbrace token.Pos // “{”的位置
        Elts   []Expr    // 复合元素列表; 或者nil
        Rbrace token.Pos // “}”的位置
}

func (x *CompositeLit) End() token.Pos

func (x *CompositeLit) Pos() token.Pos

type Decl interface {
        Node
        // 包含过滤或未导出的方法
}

type DeclStmt struct {
        Decl Decl // * GenDecl与CONST，TYPE或VAR令牌
}

func (s *DeclStmt) End() token.Pos

func (s *DeclStmt) Pos() token.Pos

type DeferStmt struct {
        Defer token.Pos // “defer”关键字的位置
        Call  *CallExpr
}

func (s *DeferStmt) End() token.Pos

func (s *DeferStmt) Pos() token.Pos

type Ellipsis struct {
        Ellipsis token.Pos // “...”的位置
        Elt      Expr      // 省略号元素类型（仅限参数列表）; 或者没有

func (x *Ellipsis) End() token.Pos

func (x *Ellipsis) Pos() token.Pos

type EmptyStmt struct {
        Semicolon token.Pos // 以下“;”的位置
        Implicit  bool      // 如果设置，“;” 在源中省略了
}

func (s *EmptyStmt) End() token.Pos

func (s *EmptyStmt) Pos() token.Pos

type Expr interface {
        Node
        // 包含过滤或未导出的方法
}

type ExprStmt struct {
        X Expr // 表达式
}

func (s *ExprStmt) End() token.Pos

func (s *ExprStmt) Pos() token.Pos

type Field struct {
        Doc     *CommentGroup // 相关文件; 或者没有
        Names   []*Ident      // 字段/方法/参数名称；或者如果匿名字段为零
        Type    Expr          // 字段/方法/参数类型
        Tag     *BasicLit     // 字段标签; 或者没有
        Comment *CommentGroup // 行注释; 或者没有
}

func (f *Field) End() token.Pos

func (f *Field) Pos() token.Pos

type FieldFilter func(name string, value reflect.Value) bool

type FieldList struct {
        Opening token.Pos // 开括号/括号的位置，如果有的话
        List    []*Field  // 字段列表; 或者没有
        Closing token.Pos // 右括号/括号的位置，如果有的话
}

func (f *FieldList) End() token.Pos

func (f *FieldList) NumFields() int

func (f *FieldList) Pos() token.Pos

type File struct {
        Doc        *CommentGroup   // 相关文件; 或者没有
        Package    token.Pos       // “package”关键字的位置
        Name       *Ident          // 包名称
        Decls      []Decl          // 顶级声明; 或者没有
        Scope      *Scope          // 包范围（仅限此文件）
        Imports    []*ImportSpec   // 在此文件中导入
        Unresolved []*Ident        // 此文件中未解析的标识符
        Comments   []*CommentGroup // 源文件中所有注释的列表
}

func MergePackageFiles(pkg *Package, mode MergeMode) *File

func (f *File) End() token.Pos

func (f *File) Pos() token.Pos

type Filter func(string) bool

type ForStmt struct {
        For  token.Pos // “for”关键字的位置
        Init Stmt      // 初始化语句; 或者没有
        Cond Expr      // 条件; 或者没有
        Post Stmt      // post iteration语句; 或者没有
        Body *BlockStmt
}

func (s *ForStmt) End() token.Pos

func (s *ForStmt) Pos() token.Pos

type FuncDecl struct {
        Doc  *CommentGroup // 相关文件; 或者没有
        Recv *FieldList    // 接收器（方法）; 或零（函数）
        Name *Ident        // 函数/方法名称
        Type *FuncType     // 函数签名：“func”关键字的参数，结果和位置
        Body *BlockStmt    // 功能体; 或者对于外部（非Go）功能为零

func (d *FuncDecl) End() token.Pos

func (d *FuncDecl) Pos() token.Pos

type FuncLit struct {
        Type *FuncType  // 函数类型
        Body *BlockStmt // 函数体
}

func (x *FuncLit) End() token.Pos

func (x *FuncLit) Pos() token.Pos

type FuncType struct {
        Func    token.Pos  // “func”关键字的位置（如果没有“func”，则为token.NoPos）
        Params  *FieldList // （传入）参数；非空
        Results *FieldList // （外向）结果；或者没有
}

func (x *FuncType) End() token.Pos

func (x *FuncType) Pos() token.Pos

token.IMPORT  *ImportSpec
token.CONST   *ValueSpec
token.TYPE    *TypeSpec
token.VAR     *ValueSpec

type GenDecl struct {
        Doc    *CommentGroup // 相关文件; 或者没有
        TokPos token.Pos     // Tok 的位置
        Tok    token.Token   // IMPORT, CONST, TYPE, VAR
        Lparen token.Pos     // “('，如果有的话）的位置
        Specs  []Spec
        Rparen token.Pos // ')'的位置，如果有的话
}

func (d *GenDecl) End() token.Pos

func (d *GenDecl) Pos() token.Pos

type GoStmt struct {
        Go   token.Pos // “go” 关键字的位置
        Call *CallExpr
}

func (s *GoStmt) End() token.Pos

func (s *GoStmt) Pos() token.Pos

type Ident struct {
        NamePos token.Pos // 确定位置
        Name    string    // 标识符名称
        Obj     *Object   // 表示对象; 或者没有
}

func NewIdent(name string) *Ident

func (x *Ident) End() token.Pos

func (id *Ident) IsExported() bool

func (x *Ident) Pos() token.Pos

func (id *Ident) String() string

type IfStmt struct {
        If   token.Pos // “if”关键字的位置
        Init Stmt      // 初始化语句; 或者没有
        Cond Expr      // 条件
        Body *BlockStmt
        Else Stmt // 别的分支; 或者没有
}

func (s *IfStmt) End() token.Pos

func (s *IfStmt) Pos() token.Pos

type ImportSpec struct {
        Doc     *CommentGroup // 相关文件; 或者没有
        Name    *Ident        // 本地包名（包括“.”）; 或者没有
        Path    *BasicLit     // 导入路径
        Comment *CommentGroup // 行注释；或者没有
        EndPos  token.Pos     // 规范结束（如果非零则覆盖Path.Pos）
}

func (s *ImportSpec) End() token.Pos

func (s *ImportSpec) Pos() token.Pos

type Importer func(imports map[string]*Object, path string) (pkg *Object, err error)

type IncDecStmt struct {
        X      Expr
        TokPos token.Pos   // Tok的位置
        Tok    token.Token // INC或DEC
}

func (s *IncDecStmt) End() token.Pos

func (s *IncDecStmt) Pos() token.Pos

type IndexExpr struct {
        X      Expr      // 表达式
        Lbrack token.Pos // “[”的位置
        Index  Expr      // 索引表达式
        Rbrack token.Pos // “]的位置
}

func (x *IndexExpr) End() token.Pos

func (x *IndexExpr) Pos() token.Pos

type InterfaceType struct {
        Interface  token.Pos  // “interface”关键字的位置
        Methods    *FieldList // 方法列表
        Incomplete bool       // 如果“方法”列表中缺少（源）方法，则为true
}

func (x *InterfaceType) End() token.Pos

func (x *InterfaceType) Pos() token.Pos

type KeyValueExpr struct {
        Key   Expr
        Colon token.Pos // “:”的位置
        Value Expr
}

func (x *KeyValueExpr) End() token.Pos

func (x *KeyValueExpr) Pos() token.Pos

type LabeledStmt struct {
        Label *Ident
        Colon token.Pos // “:”的位置
        Stmt  Stmt
}

func (s *LabeledStmt) End() token.Pos

func (s *LabeledStmt) Pos() token.Pos

type MapType struct {
        Map   token.Pos // “map”关键字的位置
        Key   Expr
        Value Expr
}

func (x *MapType) End() token.Pos

func (x *MapType) Pos() token.Pos

type MergeMode uint

const (
        // 如果设置，则排除重复的函数声明。
        FilterFuncDuplicates MergeMode = 1 << iota
        // 如果设置，则与特定的注释无关
        // AST节点（作为Doc或Comment）被排除在外。
        FilterUnassociatedComments
        // 如果设置，则排除重复的导入声明。
        FilterImportDuplicates
)

type Node interface {
        Pos() token.Pos // 属于该节点的第一个字符的位置
        End() token.Pos // 紧接在节点之后的第一个字符的位置
}

type ObjKind int

const (
        Bad ObjKind = iota // 用于错误处理
        Pkg                // 包
        Con                // 常量
        Typ                // 类型
        Var                // 变量
        Fun                // 函数或方法
        Lbl                // 标签
)

func (kind ObjKind) String() string

Kind    Data type         Data value
Pkg     *Scope            package scope
Con     int               iota for the respective declaration

type Object struct {
        Kind ObjKind
        Name string      // 声明的名称
        Decl interface{} // 对应的Field，XxxSpec，FuncDecl，LabeledStmt，AssignStmt，Scope; 或者没有
        Data interface{} // 特定对象数据；或者没有
        Type interface{} // 占位符的类型信息; 可能是零
}

func NewObj(kind ObjKind, name string) *Object

func (obj *Object) Pos() token.Pos

type Package struct {
        Name    string             // 包名称
        Scope   *Scope             // 所有文件的包范围
        Imports map[string]*Object // 包id的地图 - >包对象
        Files   map[string]*File   // 按文件名转到源文件

func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)

func (p *Package) End() token.Pos

func (p *Package) Pos() token.Pos

type ParenExpr struct {
        Lparen token.Pos // “(”的位置
        X      Expr      // 括号表达式
        Rparen token.Pos // “)”的位置
}

func (x *ParenExpr) End() token.Pos

func (x *ParenExpr) Pos() token.Pos

type RangeStmt struct {
        For        token.Pos   // “for”关键字的位置
        Key, Value Expr        // 关键，值可能是零
        TokPos     token.Pos   // Tok的位置; 如果Key == nil则无效
        Tok        token.Token // 如果Key == nil，ASSIGN，DEFINE，则为ILLEGAL
        X          Expr        // 值范围超过
        Body       *BlockStmt
}

func (s *RangeStmt) End() token.Pos

func (s *RangeStmt) Pos() token.Pos

type ReturnStmt struct {
        Return  token.Pos // “return”关键字的位置
        Results []Expr    // 结果表达式；或者没有
}

func (s *ReturnStmt) End() token.Pos

func (s *ReturnStmt) Pos() token.Pos

type Scope struct {
        Outer   *Scope
        Objects map[string]*Object
}

func NewScope(outer *Scope) *Scope

func (s *Scope) Insert(obj *Object) (alt *Object)

func (s *Scope) Lookup(name string) *Object

func (s *Scope) String() string

type SelectStmt struct {
        Select token.Pos  // “select”关键字的位置
        Body   *BlockStmt // 仅限CommClauses
}

func (s *SelectStmt) End() token.Pos

func (s *SelectStmt) Pos() token.Pos

type SelectorExpr struct {
        X   Expr   // 表达式
        Sel *Ident // 场选择器
}

func (x *SelectorExpr) End() token.Pos

func (x *SelectorExpr) Pos() token.Pos

type SendStmt struct {
        Chan  Expr
        Arrow token.Pos // “<- ”的位置
        Value Expr
}

func (s *SendStmt) End() token.Pos

func (s *SendStmt) Pos() token.Pos

type SliceExpr struct {
        X      Expr      // 表达式
        Lbrack token.Pos // “[”的位置
        Low    Expr      // 切片范围的开始；或者没有
        High   Expr      // 切片范围的结束; 或者没有
        Max    Expr      // 最大切片容量; 或者没有
        Slice3 bool      // 如果3-index切片（存在2个冒号），则为true
        Rbrack token.Pos // “]"的位置
}

func (x *SliceExpr) End() token.Pos

func (x *SliceExpr) Pos() token.Pos

type Spec interface {
        Node
        // 包含过滤或未导出的方法
}

type StarExpr struct {
        Star token.Pos // “*”的位置
        X    Expr      // 操作数
}

func (x *StarExpr) End() token.Pos

func (x *StarExpr) Pos() token.Pos

type Stmt interface {
        Node
        // 包含过滤或未导出的方法
}

type StructType struct {
        Struct     token.Pos  // “struct”关键字的位置
        Fields     *FieldList // 列表声明清单
        Incomplete bool       // 如果“字段”列表中缺少（源）字段，则为true
}

func (x *StructType) End() token.Pos

func (x *StructType) Pos() token.Pos

type SwitchStmt struct {
        Switch token.Pos  // “switch”关键字的位置
        Init   Stmt       // 初始化语句; 或者没有
        Tag    Expr       // 标签表达; 或者没有
        Body   *BlockStmt // 仅限CaseClauses
}

func (s *SwitchStmt) End() token.Pos

func (s *SwitchStmt) Pos() token.Pos

type TypeAssertExpr struct {
        X      Expr      // 表达式
        Lparen token.Pos // “(”的位置
        Type   Expr      // 断言类型; nil表示类型开关X.(type)
        Rparen token.Pos // “)"的位置
}

func (x *TypeAssertExpr) End() token.Pos

func (x *TypeAssertExpr) Pos() token.Pos

type TypeSpec struct {
        Doc     *CommentGroup // 相关文件；或者没有
        Name    *Ident        // 类型名称
        Assign  token.Pos     // '='的位置，如果有的话
        Type    Expr          // *Ident，*ParenExpr，*SelectorExpr，*StarExpr或任何*XxxTypes
        Comment *CommentGroup // 行注释；或者没有
}

func (s *TypeSpec) End() token.Pos

func (s *TypeSpec) Pos() token.Pos

type TypeSwitchStmt struct {
        Switch token.Pos  // “switch”关键字的位置
        Init   Stmt       // 初始化语句; 或者没有
        Assign Stmt       // x := y.(type)或y.(type)
        Body   *BlockStmt // 仅限CaseClauses
}

func (s *TypeSwitchStmt) End() token.Pos

func (s *TypeSwitchStmt) Pos() token.Pos

type UnaryExpr struct {
        OpPos token.Pos   // Op 的位置
        Op    token.Token // 操作者
        X     Expr        // 操作数
}

func (x *UnaryExpr) End() token.Pos

func (x *UnaryExpr) Pos() token.Pos

type ValueSpec struct {
        Doc     *CommentGroup // 相关文件; 或者没有
        Names   []*Ident      // 值名称（len(Names) > 0）
        Type    Expr          // 值类型; 或者没有
        Values  []Expr        // 初始值; 或者没有
        Comment *CommentGroup // 行注释 或者没有
}

func (s *ValueSpec) End() token.Pos

func (s *ValueSpec) Pos() token.Pos

type Visitor interface {
        Visit(node Node) (w Visitor)
}