【Go】go的AST操作相关源代码研读解析-不定期更新

本文链接：https://blog.csdn.net/weixin_62645763/article/details/134196015

最近在弄go的语法树插入和扫描，去看了go的AST相关的源代码，记录一下学习到的一些和go的语法树操作相关的内容，关于代码的理解大多都在代码的注释中
之后应该会不定期更新完善本文

文章目录

首先明确一下什么是表达式、声明和定义、语句

表达式

在编程语言中，表达式（Expression）是由变量、常量、运算符和函数调用等组合而成的代码片段，用于产生一个值。表达式可以用来计算、比较、赋值和执行其他操作。表达式可以包含以下元素：

变量和常量：表示存储值的标识符或字面值。例如，x、5、“hello”。
运算符：用于对操作数进行运算的符号。例如，+、-、*、/。
函数调用：使用函数名及其参数列表来调用函数并返回结果。例如，sum(2, 3)。
表达式组合：多个表达式可以通过运算符和括号组合起来创建更复杂的表达式。例如，(x + y) * z。

声明和定义

声明是引入标识符，还没分配存储空间

定义才为标识符分配存储空间

语句

语句（Statement）是一条执行特定操作的代码行或代码块。语句用于告诉计算机执行特定的任务或操作，以实现程序的逻辑和功能。

语句可以包含以下类型的操作：

赋值语句：用于将一个值赋给一个变量或数据结构。
控制流语句：用于控制程序的执行流程，包括条件语句（如 if-else 和 switch）、循环语句（如 for 和 while）以及跳转语句（如 break 和 continue）等。
函数调用语句：用于调用函数并执行其中的代码。
声明/定义语句：用于声明/定义变量、常量、函数和数据类型等。
I/O 语句：用于输入和输出操作，如打印输出、读取输入等。
异常处理语句：用于捕获和处理程序中的异常情况。

AST的主要节点类型

Expr：表达式节点

Decl：声明节点

Stmt：语句节点

Decl节点和Stmt节点区别

在 Go 语言中，Decl 表示声明（Declaration），Stmt 表示语句（Statement）。它们在语法树（AST）中表示不同的概念，并且具有一定的关系。

Declaration（声明）：
- 在 Go 语言中，声明（Declaration）用于引入新的标识符（如变量、常量、函数、类型等）。
- 在语法树中，声明节点（Decl）表示一个声明的抽象概念，可以是函数声明、变量声明、常量声明等。
- 例如，VarDecl 表示变量声明，FuncDecl 表示函数声明，ConstDecl 表示常量声明。
Statement（语句）：
- 在 Go 语言中，语句（Statement）用于执行特定的操作或任务。
- 在语法树中，语句节点（Stmt）表示一个语句的抽象概念，可以是赋值语句、条件语句、循环语句等。
- 例如，AssignStmt 表示赋值语句，IfStmt 表示条件语句，ForStmt 表示循环语句。

在语法树中，声明节点和语句节点通常作为树的不同分支，表示程序的不同部分。声明节点用于引入标识符，而语句节点用于执行操作。

例如，考虑以下 Go 代码片段：

var x int          // 变量声明
y := 10            // 短变量声明
func foo() {       // 函数声明
    if y > 0 {     // 条件语句
        x = y      // 赋值语句
    } else {
        x = -y
    }
}

在该代码片段的语法树中，var x int 和 y := 10 是变量声明，它们是 Decl 节点。func foo() { ... } 是函数声明，也是 Decl 节点。if y > 0 { ... } 是条件语句，x = y 和 x = -y 是赋值语句，它们是 Stmt 节点。

获取AST根节点

要获得 AST（抽象语法树）的根节点，可以在解析源代码时使用 go/parser 包的 ParseFile 函数。该函数会返回一个 *ast.File 类型的节点，代表整个源代码文件的 AST。

e.g.

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

func main() {
	fset := token.NewFileSet()
    // 解析源代码文件，生成 AST，返回根节点，即file，是 *ast.File 类型（见下面有解释这个结构体）
    // parser.ParseComments模式保留注释
	file, err := parser.ParseFile(fset, "main.go", nil, parser.ParseComments)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 获取 AST 的根节点
	rootNode := file

	// 在这里可以对根节点进行进一步处理

	fmt.Println(rootNode)
}

ast.File 结构体

ast.File 是 Go 语言中表示源代码文件的抽象语法树（Abstract Syntax Tree，AST）的结构体之一。它用于表示整个源代码文件的结构和内容。

在 Go 语言中，ast.File 结构体包含了表示源代码文件的各个部分的字段，例如导入声明、包声明、函数声明、变量声明、类型声明等。它是构建整个源代码文件的 AST 的核心结构。

type File struct {
    Doc        *CommentGroup
    Package    token.Pos
    Name       *Ident
    Decls      []Decl
    Scope      *Scope
    Imports    []*ImportSpec
    Unresolved []*Ident
    Comments   []*CommentGroup
}

以下是 ast.File 结构体的一些常用字段：

Name：表示文件的包名，类型为 *ast.Ident，其中 ast.Ident 表示标识符。
Decls：表示文件中的声明列表，类型为 []ast.Decl，其中 ast.Decl 表示声明。
- ast.File 结构体中的 Decls 字段是一个 []ast.Decl 类型的切片，用于表示源代码文件中的声明列表。每个声明都是 ast.Decl 类型的结构体，表示源代码中的一个顶级声明。
  
  以下是 ast.Decl 结构体的一些常见子类型：
  - ast.GenDecl：通用声明，用于表示导入声明、常量声明、变量声明和类型声明等。其中 ast.GenDecl 结构体包含以下字段：
  Tok：表示声明的类型，如 token.IMPORT、token.CONST、token.VAR、token.TYPE 等。
  Specs：表示具体的声明规范列表，类型为 []ast.Spec，其中 ast.Spec 表示具体的声明规范。——理解为这类声明中的具体每个声明句子
  - ast.FuncDecl：函数声明，用于表示函数声明。其中 ast.FuncDecl 结构体包含以下字段：
  Name：表示函数或方法的名称，类型为 *ast.Ident，其中 ast.Ident 表示标识符。
  Type：表示函数或方法的类型，类型为 *ast.FuncType，其中 ast.FuncType 表示函数类型。
  Body：表示函数或方法的函数体，类型为 *ast.BlockStmt，其中 ast.BlockStmt 表示代码块即{…}。
  - 其他声明类型，如 ast.TypeSpec、ast.ValueSpec 等，用于表示类型声明和变量声明。

通过遍历 ast.File 的 Decls 切片，可以访问源代码文件中的每个顶级声明，进而获取声明的具体信息和进行相应的处理和分析。

Imports：表示导入声明列表，类型为 []*ast.ImportSpec，其中 ast.ImportSpec 表示导入规范。
Scope：表示文件的作用域，类型为 *ast.Scope，其中 ast.Scope 表示作用域。
Comments：表示文件中的注释列表，类型为 []*ast.CommentGroup，其中 ast.CommentGroup 表示一组注释。

一个很快的插入一整段代码的方法——利用parser.ParseFile

具体分析见代码注释

func getStmtsFromString(stmts_str string) []ast.Stmt {
	// 需要采取一些特别的方法来处理，因为标准库中的 parser.ParseFile 需要一个完整的 Go 源文件结构（包括包声明等）来解析，所以要加上package p;，并且把我们要插入的语句放到一个函数里
    // 注意func _()这个func名字不能更改，是go函数关键字
    // 通过Delcs列表，可以选择第几个声明，再用类型断言，判断并转化为函数声明，获取函数声明的函数体中的List，即获得要插入的代码
	stmts_ast_file, err := parser.ParseFile(token.NewFileSet(), "", "package p; func _() {"+stmts_str+"}; func _() {\"test\"}", parser.AllErrors)

	if err != nil {
		log.Fatalf("parse code to insert: %v", err)
	}
	stmts := stmts_ast_file.Decls[0].(*ast.FuncDecl).Body.List

	return stmts
}

func insertMainFunc(file *ast.File) {
	// 使用 ast.Walk 遍历整个 AST。
    // 要插入的代码
	codeToInsert := `
	go test(){
		fmt.Println("test")
	}
	`
	stmts := getStmtsFromString(codeToInsert)

	ast.Inspect(file, func(n ast.Node) bool {
		fn, isFn := n.(*ast.FuncDecl)
        // 插入到main函数中
		if isFn && fn.Name.Name == "main" {
			fn.Body.List = append(stmts, fn.Body.List...)
		}
		return true
	})

}

想单独插入某个声明/语句

感觉没办法完整的总结

大概就是：

根据源代码，确定你要插入的句子属于什么节点，规范是什么，构造出你要插入的句子

找到你要插入的位置进行插入

之后有空再总结一下各种类型的声明/语句怎么插入吧

ast.Inspect——语法树遍历相关

ast.Inspect 函数是 Go 语言标准库中 go/ast 包提供的一个便利函数，用于遍历抽象语法树（AST）并应用一个回调函数来处理每个节点。

函数签名如下：
func Inspect(node ast.Node, f func(ast.Node) bool)

Inspect 函数接受两个参数：

node：要遍历的 AST 根节点。
f：回调函数，接受一个 ast.Node 类型的参数，并返回一个布尔值。回调函数用于处理每个节点，返回 true 表示继续遍历子节点，返回 false 表示停止遍历子节点。

os.Getenv()

获取环境变量，包括系统变量和用户变量

系统级别的环境变量是在操作系统级别设置的，对所有用户都可见。这些变量通常包含系统的配置信息和全局设置。
用户级别的环境变量是在特定用户级别设置的，只对该用户可见。这些变量通常包含用户的个人配置和偏好设置。

ast.Decl 结构体

一些常见子类型：

ast.GenDecl：通用声明，用于表示导入声明、常量声明、变量声明和类型声明等。其中 ast.GenDecl 结构体包含以下字段：

Tok：表示声明的类型，如 token.IMPORT、token.CONST、token.VAR、token.TYPE 等。
Specs：表示具体的声明规范列表，类型为 []ast.Spec，其中 ast.Spec 表示具体的声明规范。——理解为这类声明中的具体每个声明句子

ast.FuncDecl：函数声明，用于表示函数声明。其中 ast.FuncDecl 结构体包含以下字段：

Name：表示函数或方法的名称，类型为 *ast.Ident，其中 ast.Ident 表示标识符。
Type：表示函数或方法的类型，类型为 *ast.FuncType，其中 ast.FuncType 表示函数类型。
Body：表示函数或方法的函数体，类型为 *ast.BlockStmt，其中 ast.BlockStmt 表示代码块。

其他声明类型，如 ast.TypeSpec、ast.ValueSpec 等，用于表示类型声明和变量声明。

通过遍历 ast.File 的 Decls 切片，可以访问源代码文件中的每个顶级声明，进而获取声明的具体信息和进行相应的处理和分析。

ast.ImportSpec结构体

An ImportSpec node represents a single package import.

在AST上插入import结点的规范

type ImportSpec struct {
    Doc     *CommentGroup // 关联的文档注释，或者为 nil
    Name    *Ident        // 导入的包的别名，即本地包名，包括 .，若不给别名则可设为_；或者为 nil
    Path    *BasicLit     // 要导入的包的路径
    Comment *CommentGroup // 行注释，或者为 nil
    EndPos  token.Pos     // 规范的结束位置，为整数值，EndPos的值为0时，表示导入规范没有明确的结束位置
    // token.Pos表示AST的位置信息
}

eg:

toImport := &ast.ImportSpec{
    Name: &ast.Ident{
        Name: "_",		// _表示不设置别名
    },
    Path: &ast.BasicLit{
        ValuePos: 0,	// 将我们要import的包语句插入到最开头
        Kind:     token.STRING,
        Value:    packageName,
    },
    EndPos: 0,
}

go/ast.go源代码研读

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package ast declares the types used to represent syntax trees for Go
// packages.
package ast

import (
	"go/token"
	"strings"
)

// ----------------------------------------------------------------------------
// Interfaces
//
// There are 3 main classes of nodes: Expressions and type nodes,
// statement nodes, and declaration nodes. The node names usually
// match the corresponding Go spec production names to which they
// correspond. The node fields correspond to the individual parts
// of the respective productions.
//
// All nodes contain position information marking the beginning of
// the corresponding source text segment; it is accessible via the
// Pos accessor method. Nodes may contain additional position info
// for language constructs where comments may be found between parts
// of the construct (typically any larger, parenthesized subpart).
// That position information is needed to properly position comments
// when printing the construct.

// All node types implement the Node interface.
// 所有节点类型都要实现这个接口，用于指示位置信息
type Node interface {
	Pos() token.Pos // position of first character belonging to the node
	End() token.Pos // position of first character immediately after the node
}

// 三种主要节点接口：表达式、语句、声明
// All expression nodes implement the Expr interface.
// 表达式节点接口
type Expr interface {
	Node
	exprNode()
}

// All statement nodes implement the Stmt interface.
// 语句节点接口
type Stmt interface {
	Node
	stmtNode()
}

// All declaration nodes implement the Decl interface.
// 声明节点接口
type Decl interface {
	Node
	declNode()
}

// ----------------------------------------------------------------------------
// Comments 注释

// A Comment node represents a single //-style or /*-style comment.
//
// The Text field contains the comment text without carriage returns (\r) that
// may have been present in the source. Because a comment's end position is
// computed using len(Text), the position reported by End() does not match the
// true source end position for comments containing carriage returns.
type Comment struct {
	Slash token.Pos // position of "/" starting the comment
	Text  string    // comment text (excluding '\n' for //-style comments)
}

func (c *Comment) Pos() token.Pos { return c.Slash }
func (c *Comment) End() token.Pos { return token.Pos(int(c.Slash) + len(c.Text)) }

// A CommentGroup represents a sequence of comments
// with no other tokens and no empty lines between.
type CommentGroup struct {
	List []*Comment // len(List) > 0
}

func (g *CommentGroup) Pos() token.Pos { return g.List[0].Pos() }
func (g *CommentGroup) End() token.Pos { return g.List[len(g.List)-1].End() }

func isWhitespace(ch byte) bool { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' }

func stripTrailingWhitespace(s string) string {
	i := len(s)
	for i > 0 && isWhitespace(s[i-1]) {
		i--
	}
	return s[0:i]
}

// Text returns the text of the comment.
// Comment markers (//, /*, and */), the first space of a line comment, and
// leading and trailing empty lines are removed.
// Comment directives like "//line" and "//go:noinline" are also removed.
// Multiple empty lines are reduced to one, and trailing space on lines is trimmed.
// Unless the result is empty, it is newline-terminated.
func (g *CommentGroup) Text() string {
	if g == nil {
		return ""
	}
	comments := make([]string, len(g.List))
	for i, c := range g.List {
		comments[i] = c.Text
	}

	lines := make([]string, 0, 10) // most comments are less than 10 lines
	for _, c := range comments {
		// Remove comment markers.
		// The parser has given us exactly the comment text.
		switch c[1] {
		case '/':
			//-style comment (no newline at the end)
			c = c[2:]
			if len(c) == 0 {
				// empty line
				break
			}
			if c[0] == ' ' {
				// strip first space - required for Example tests
				c = c[1:]
				break
			}
			if isDirective(c) {
				// Ignore //go:noinline, //line, and so on.
				continue
			}
		case '*':
			/*-style comment */
			c = c[2 : len(c)-2]
		}

		// Split on newlines.
		cl := strings.Split(c, "\n")

		// Walk lines, stripping trailing white space and adding to list.
		for _, l := range cl {
			lines = append(lines, stripTrailingWhitespace(l))
		}
	}

	// Remove leading blank lines; convert runs of
	// interior blank lines to a single blank line.
	n := 0
	for _, line := range lines {
		if line != "" || n > 0 && lines[n-1] != "" {
			lines[n] = line
			n++
		}
	}
	lines = lines[0:n]

	// Add final "" entry to get trailing newline from Join.
	if n > 0 && lines[n-1] != "" {
		lines = append(lines, "")
	}

	return strings.Join(lines, "\n")
}

// isDirective reports whether c is a comment directive.
// This code is also in go/printer.
func isDirective(c string) bool {
	// "//line " is a line directive.
	// "//extern " is for gccgo.
	// "//export " is for cgo.
	// (The // has been removed.)
	if strings.HasPrefix(c, "line ") || strings.HasPrefix(c, "extern ") || strings.HasPrefix(c, "export ") {
		return true
	}

	// "//[a-z0-9]+:[a-z0-9]"
	// (The // has been removed.)
	colon := strings.Index(c, ":")
	if colon <= 0 || colon+1 >= len(c) {
		return false
	}
	for i := 0; i <= colon+1; i++ {
		if i == colon {
			continue
		}
		b := c[i]
		if !('a' <= b && b <= 'z' || '0' <= b && b <= '9') {
			return false
		}
	}
	return true
}

// ----------------------------------------------------------------------------
// Expressions and types 表达式和类型

// A Field represents a Field declaration list in a struct type,
// a method list in an interface type, or a parameter/result declaration
// in a signature.
// Field.Names is nil for unnamed parameters (parameter lists which only contain types)
// and embedded struct fields. In the latter case, the field name is the type name.
type Field struct {		// 可以用于描述结构体的成员、函数的参数或方法的接收器
	Doc     *CommentGroup // associated documentation; or nil
	Names   []*Ident      // field/method/(type) parameter names; or nil
	Type    Expr          // field/method/parameter type; or nil
	Tag     *BasicLit     // field tag; or nil
	Comment *CommentGroup // line comments; or nil
}

func (f *Field) Pos() token.Pos {
	if len(f.Names) > 0 {
		return f.Names[0].Pos()
	}
	if f.Type != nil {
		return f.Type.Pos()
	}
	return token.NoPos
}

func (f *Field) End() token.Pos {
	if f.Tag != nil {
		return f.Tag.End()
	}
	if f.Type != nil {
		return f.Type.End()
	}
	if len(f.Names) > 0 {
		return f.Names[len(f.Names)-1].End()
	}
	return token.NoPos
}

// A FieldList represents a list of Fields, enclosed by parentheses,
// curly braces, or square brackets.
type FieldList struct {
	Opening token.Pos // position of opening parenthesis/brace/bracket, if any
	List    []*Field  // field list; or nil
	Closing token.Pos // position of closing parenthesis/brace/bracket, if any
}

func (f *FieldList) Pos() token.Pos {
	if f.Opening.IsValid() {
		return f.Opening
	}
	// the list should not be empty in this case;
	// be conservative and guard against bad ASTs
	if len(f.List) > 0 {
		return f.List[0].Pos()
	}
	return token.NoPos
}

func (f *FieldList) End() token.Pos {
	if f.Closing.IsValid() {
		return f.Closing + 1
	}
	// the list should not be empty in this case;
	// be conservative and guard against bad ASTs
	if n := len(f.List); n > 0 {
		return f.List[n-1].End()
	}
	return token.NoPos
}

// NumFields returns the number of parameters or struct fields represented by a FieldList.
func (f *FieldList) NumFields() int {
	n := 0
	if f != nil {
		for _, g := range f.List {
			m := len(g.Names)
			if m == 0 {
				m = 1
			}
			n += m
		}
	}
	return n
}

// An expression is represented by a tree consisting of one
// or more of the following concrete expression nodes.
type (
	// A BadExpr node is a placeholder for an expression containing
	// syntax errors for which a correct expression node cannot be
	// created.
	//
	BadExpr struct {
		From, To token.Pos // position range of bad expression
	}

	// An Ident node represents an identifier.
    // 标识符
	Ident struct {	
		NamePos token.Pos // identifier position
		Name    string    // identifier name
		Obj     *Object   // denoted object; or nil
	}

	// An Ellipsis node stands for the "..." type in a
	// parameter list or the "..." length in an array type.
	// 省略号...
	Ellipsis struct {
		Ellipsis token.Pos // position of "..."
		Elt      Expr      // ellipsis element type (parameter lists only); or nil
	}

	// A BasicLit node represents a literal of basic 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`
	}
 
	// A FuncLit node represents a function literal.
    // 函数字面量（匿名函数）：用于表示源代码中的函数字面量，也称为匿名函数或闭包。函数字面量是一种在代码中直接定义函数的方式，而不需要给函数命名。
    // 函数字面量通常用于函数作为值的场景，可以作为函数参数传递、存储在变量中或直接调用等。
	FuncLit struct {
		Type *FuncType  // function type，包括参数和返回值的类型
		Body *BlockStmt // function body，函数体
	}

	// A CompositeLit node represents a composite literal.
    // 复合字面量：是一种直接在代码中创建复合数据类型（如结构体、数组、映射等）的方式，写在{}中的
	CompositeLit struct {
		Type       Expr      // literal type; or nil
		Lbrace     token.Pos // position of "{"
		Elts       []Expr    // list of composite elements; or nil，元素列表
		Rbrace     token.Pos // position of "}"
		Incomplete bool      // true if (source) expressions are missing in the Elts list
	}

	// A ParenExpr node represents a parenthesized expression.
    // 括号表达式：通常用于控制表达式的求值顺序、明确运算符的优先级、消除歧义或提高代码的可读性。
	ParenExpr struct {
		Lparen token.Pos // position of "("
		X      Expr      // parenthesized expression
		Rparen token.Pos // position of ")"
	}

	// A SelectorExpr node represents an expression followed by a selector.
    // 选择器，就是.
	SelectorExpr struct {
		X   Expr   // expression
		Sel *Ident // field selector
	}

	// An IndexExpr node represents an expression followed by an index.
    // 索引表达式
	IndexExpr struct {
		X      Expr      // expression，被索引的对象，可以是数组、切片、字符串或映射等
		Lbrack token.Pos // position of "["
		Index  Expr      // index expression
		Rbrack token.Pos // position of "]"
	}

	// An IndexListExpr node represents an expression followed by multiple
	// indices.
    // 索引列表表达式
	IndexListExpr struct {
		X       Expr      // expression
		Lbrack  token.Pos // position of "["
		Indices []Expr    // index expressions
		Rbrack  token.Pos // position of "]"
	}

	// A SliceExpr node represents an expression followed by slice indices.
    // 切片
	SliceExpr struct {
		X      Expr      // expression
		Lbrack token.Pos // position of "["
		Low    Expr      // begin of slice range; or nil
		High   Expr      // end of slice range; or nil
		Max    Expr      // maximum capacity of slice; or nil
		Slice3 bool      // true if 3-index slice (2 colons present)
		Rbrack token.Pos // position of "]"
	}

	// A TypeAssertExpr node represents an expression followed by a
	// type assertion.
	// 类型断言表达式
	TypeAssertExpr struct {
		X      Expr      // expression
		Lparen token.Pos // position of "("
		Type   Expr      // asserted type; nil means type switch X.(type)
		Rparen token.Pos // position of ")"
	}

	// A CallExpr node represents an expression followed by an argument list.
    // 函数调用表达式：用于调用函数并传递参数
	CallExpr struct {
        Fun      Expr      // function expression，函数表达式，表示被调用的函数,如test("test")，则这里是Ident
		Lparen   token.Pos // position of "("
		Args     []Expr    // function arguments; or nil
		Ellipsis token.Pos // position of "..." (token.NoPos if there is no "...")，省略号 ... 的位置（如果有的话），用于表示可变参数函数。
		Rparen   token.Pos // position of ")"
	}

	// A StarExpr node represents an expression of the form "*" Expression.
	// Semantically it could be a unary "*" expression, or a pointer type.
	// 即*
	StarExpr struct {
		Star token.Pos // position of "*"
		X    Expr      // operand
	}

	// A UnaryExpr node represents a unary expression.
	// Unary "*" expressions are represented via StarExpr nodes.
	//
	UnaryExpr struct {
		OpPos token.Pos   // position of Op
		Op    token.Token // operator
		X     Expr        // operand
	}

	// A BinaryExpr node represents a binary expression.
    // 二元表达式：如加减乘除
	BinaryExpr struct {
		X     Expr        // left operand
		OpPos token.Pos   // position of Op
		Op    token.Token // operator
		Y     Expr        // right operand
	}

	// A KeyValueExpr node represents (key : value) pairs
	// in composite literals.
	// 键值对表达式，Key: Value
	KeyValueExpr struct {
		Key   Expr
		Colon token.Pos // position of ":"
		Value Expr
	}
)

// The direction of a channel type is indicated by a bit
// mask including one or both of the following constants.
type ChanDir int

const (
	SEND ChanDir = 1 << iota
	RECV
)

// A type is represented by a tree consisting of one
// or more of the following type-specific expression
// nodes.
type (
	// An ArrayType node represents an array or slice type.
	ArrayType struct {
		Lbrack token.Pos // position of "["
		Len    Expr      // Ellipsis node for [...]T array types, nil for slice types
		Elt    Expr      // element type
	}

	// A StructType node represents a struct type.
	StructType struct {
		Struct     token.Pos  // position of "struct" keyword
		Fields     *FieldList // list of field declarations
		Incomplete bool       // true if (source) fields are missing in the Fields list
	}

	// Pointer types are represented via StarExpr nodes.

	// A FuncType node represents a function type.
	FuncType struct {
		Func       token.Pos  // position of "func" keyword (token.NoPos if there is no "func")
		TypeParams *FieldList // type parameters; or nil
		Params     *FieldList // (incoming) parameters; non-nil
		Results    *FieldList // (outgoing) results; or nil
	}

	// An InterfaceType node represents an interface type.
	InterfaceType struct {
		Interface  token.Pos  // position of "interface" keyword
		Methods    *FieldList // list of embedded interfaces, methods, or types
		Incomplete bool       // true if (source) methods or types are missing in the Methods list
	}

	// A MapType node represents a map type.
	MapType struct {
		Map   token.Pos // position of "map" keyword
		Key   Expr
		Value Expr
	}

	// A ChanType node represents a channel type.
	ChanType struct {
		Begin token.Pos // position of "chan" keyword or "<-" (whichever comes first)
		Arrow token.Pos // position of "<-" (token.NoPos if there is no "<-")
		Dir   ChanDir   // channel direction
		Value Expr      // value type
	}
)

// Pos and End implementations for expression/type nodes.

func (x *BadExpr) Pos() token.Pos  { return x.From }
func (x *Ident) Pos() token.Pos    { return x.NamePos }
func (x *Ellipsis) Pos() token.Pos { return x.Ellipsis }
func (x *BasicLit) Pos() token.Pos { return x.ValuePos }
func (x *FuncLit) Pos() token.Pos  { return x.Type.Pos() }
func (x *CompositeLit) Pos() token.Pos {
	if x.Type != nil {
		return x.Type.Pos()
	}
	return x.Lbrace
}
func (x *ParenExpr) Pos() token.Pos      { return x.Lparen }
func (x *SelectorExpr) Pos() token.Pos   { return x.X.Pos() }
func (x *IndexExpr) Pos() token.Pos      { return x.X.Pos() }
func (x *IndexListExpr) Pos() token.Pos  { return x.X.Pos() }
func (x *SliceExpr) Pos() token.Pos      { return x.X.Pos() }
func (x *TypeAssertExpr) Pos() token.Pos { return x.X.Pos() }
func (x *CallExpr) Pos() token.Pos       { return x.Fun.Pos() }
func (x *StarExpr) Pos() token.Pos       { return x.Star }
func (x *UnaryExpr) Pos() token.Pos      { return x.OpPos }
func (x *BinaryExpr) Pos() token.Pos     { return x.X.Pos() }
func (x *KeyValueExpr) Pos() token.Pos   { return x.Key.Pos() }
func (x *ArrayType) Pos() token.Pos      { return x.Lbrack }
func (x *StructType) Pos() token.Pos     { return x.Struct }
func (x *FuncType) Pos() token.Pos {
	if x.Func.IsValid() || x.Params == nil { // see issue 3870
		return x.Func
	}
	return x.Params.Pos() // interface method declarations have no "func" keyword
}
func (x *InterfaceType) Pos() token.Pos { return x.Interface }
func (x *MapType) Pos() token.Pos       { return x.Map }
func (x *ChanType) Pos() token.Pos      { return x.Begin }

func (x *BadExpr) End() token.Pos { return x.To }
func (x *Ident) End() token.Pos   { return token.Pos(int(x.NamePos) + len(x.Name)) }
func (x *Ellipsis) End() token.Pos {
	if x.Elt != nil {
		return x.Elt.End()
	}
	return x.Ellipsis + 3 // len("...")
}
func (x *BasicLit) End() token.Pos       { return token.Pos(int(x.ValuePos) + len(x.Value)) }
func (x *FuncLit) End() token.Pos        { return x.Body.End() }
func (x *CompositeLit) End() token.Pos   { return x.Rbrace + 1 }
func (x *ParenExpr) End() token.Pos      { return x.Rparen + 1 }
func (x *SelectorExpr) End() token.Pos   { return x.Sel.End() }
func (x *IndexExpr) End() token.Pos      { return x.Rbrack + 1 }
func (x *IndexListExpr) End() token.Pos  { return x.Rbrack + 1 }
func (x *SliceExpr) End() token.Pos      { return x.Rbrack + 1 }
func (x *TypeAssertExpr) End() token.Pos { return x.Rparen + 1 }
func (x *CallExpr) End() token.Pos       { return x.Rparen + 1 }
func (x *StarExpr) End() token.Pos       { return x.X.End() }
func (x *UnaryExpr) End() token.Pos      { return x.X.End() }
func (x *BinaryExpr) End() token.Pos     { return x.Y.End() }
func (x *KeyValueExpr) End() token.Pos   { return x.Value.End() }
func (x *ArrayType) End() token.Pos      { return x.Elt.End() }
func (x *StructType) End() token.Pos     { return x.Fields.End() }
func (x *FuncType) End() token.Pos {
	if x.Results != nil {
		return x.Results.End()
	}
	return x.Params.End()
}
func (x *InterfaceType) End() token.Pos { return x.Methods.End() }
func (x *MapType) End() token.Pos       { return x.Value.End() }
func (x *ChanType) End() token.Pos      { return x.Value.End() }

// exprNode() ensures that only expression/type nodes can be
// assigned to an Expr.
func (*BadExpr) exprNode()        {}
func (*Ident) exprNode()          {}
func (*Ellipsis) exprNode()       {}
func (*BasicLit) exprNode()       {}
func (*FuncLit) exprNode()        {}
func (*CompositeLit) exprNode()   {}
func (*ParenExpr) exprNode()      {}
func (*SelectorExpr) exprNode()   {}
func (*IndexExpr) exprNode()      {}
func (*IndexListExpr) exprNode()  {}
func (*SliceExpr) exprNode()      {}
func (*TypeAssertExpr) exprNode() {}
func (*CallExpr) exprNode()       {}
func (*StarExpr) exprNode()       {}
func (*UnaryExpr) exprNode()      {}
func (*BinaryExpr) exprNode()     {}
func (*KeyValueExpr) exprNode()   {}

func (*ArrayType) exprNode()     {}
func (*StructType) exprNode()    {}
func (*FuncType) exprNode()      {}
func (*InterfaceType) exprNode() {}
func (*MapType) exprNode()       {}
func (*ChanType) exprNode()      {}

// ----------------------------------------------------------------------------
// Convenience functions for Idents

// NewIdent creates a new Ident without position.
// Useful for ASTs generated by code other than the Go parser.
func NewIdent(name string) *Ident { return &Ident{token.NoPos, name, nil} }

// IsExported reports whether name starts with an upper-case letter.
func IsExported(name string) bool { return token.IsExported(name) }

// IsExported reports whether id starts with an upper-case letter.
func (id *Ident) IsExported() bool { return token.IsExported(id.Name) }

func (id *Ident) String() string {
	if id != nil {
		return id.Name
	}
	return "<nil>"
}

// ----------------------------------------------------------------------------
// Statements 语句

// A statement is represented by a tree consisting of one
// or more of the following concrete statement nodes.
// 语句由一个树表示，该树由以下一个或多个具体语句节点组成。
type (
	// A Bad Stmt node is a placeholder for statements containing
	// syntax errors for which no correct statement nodes can be
	// created.
	//
	BadStmt struct {
		From, To token.Pos // position range of bad statement
	}

	// A DeclStmt node represents a declaration in a statement list.
    // 声明语句
	DeclStmt struct {
		Decl Decl // *GenDecl with CONST, TYPE, or VAR token
	}

	// An EmptyStmt node represents an empty statement.
	// The "position" of the empty statement is the position
	// of the immediately following (explicit or implicit) semicolon.
	//
	EmptyStmt struct {
		Semicolon token.Pos // position of following ";"
		Implicit  bool      // if set, ";" was omitted in the source
	}

	// A LabeledStmt node represents a labeled statement.
	LabeledStmt struct {
		Label *Ident
		Colon token.Pos // position of ":"
		Stmt  Stmt
	}

	// An ExprStmt node represents a (stand-alone) expression
	// in a statement list.
	// 表达式语句：是指由一个表达式组成的语句。表达式可以是函数调用、运算等。
	ExprStmt struct {
		X Expr // expression
	}

	// A SendStmt node represents a send statement.
	SendStmt struct {
		Chan  Expr
		Arrow token.Pos // position of "<-"
		Value Expr
	}

	// An IncDecStmt node represents an increment or decrement statement.
	IncDecStmt struct {
		X      Expr
		TokPos token.Pos   // position of Tok
		Tok    token.Token // INC or DEC
	}

	// An AssignStmt node represents an assignment or
	// a short variable declaration.
	// 赋值语句
	AssignStmt struct {
		Lhs    []Expr	// 赋值符号左侧的表达式列表
		TokPos token.Pos   // position of Tok，赋值符号的位置信息
		Tok    token.Token // assignment token, DEFINE，赋值符号
		Rhs    []Expr	// 赋值符号右侧的表达式列表
	}

	// A GoStmt node represents a go statement.
    // go语句
	GoStmt struct {
		Go   token.Pos // position of "go" keyword，go关键字的位置信息
		Call *CallExpr	// 函数调用表达式
	}

	// A DeferStmt node represents a defer statement.
    // Defer语句
    // 当在函数中遇到 defer 关键字时，它会将紧随其后的函数调用表达式添加到一个特殊的延迟调用栈中，而不会立即执行。
    // 而是在包裹该函数的函数执行完毕之后，按照后进先出（LIFO）的顺序执行这些延迟调用。
    // 换句话说，defer 语句会将函数调用推迟到包裹函数返回之前执行。
	DeferStmt struct {
		Defer token.Pos  // position of "defer" keyword，Defer关键字的位置信息
		Call  *CallExpr	 // 函数调用表达式
	}

	// A ReturnStmt node represents a return statement.
    // return语句
	ReturnStmt struct {
		Return  token.Pos // position of "return" keyword
		Results []Expr    // result expressions; or nil
	}

	// A BranchStmt node represents a break, continue, goto,
	// or fallthrough statement.
	//
	BranchStmt struct {
		TokPos token.Pos   // position of Tok
		Tok    token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
		Label  *Ident      // label name; or nil
	}

	// A BlockStmt node represents a braced statement list.
	BlockStmt struct {
		Lbrace token.Pos // position of "{"
		List   []Stmt
		Rbrace token.Pos // position of "}", if any (may be absent due to syntax error)
	}

	// An IfStmt node represents an if statement.
    // if语句
	IfStmt struct {
		If   token.Pos // position of "if" keyword
		Init Stmt      // initialization statement; or nil
		Cond Expr      // condition
		Body *BlockStmt
		Else Stmt // else branch; or nil
	}

	// A CaseClause represents a case of an expression or type switch statement.
    // case语句
	CaseClause struct {
		Case  token.Pos // position of "case" or "default" keyword
		List  []Expr    // list of expressions or types; nil means default case
		Colon token.Pos // position of ":"
		Body  []Stmt    // statement list; or nil
	}

	// A SwitchStmt node represents an expression switch statement.
    // switch语句
	SwitchStmt struct {
		Switch token.Pos  // position of "switch" keyword
		Init   Stmt       // initialization statement; or nil
		Tag    Expr       // tag expression; or nil
		Body   *BlockStmt // CaseClauses only
	}

	// A TypeSwitchStmt node represents a type switch statement.
	TypeSwitchStmt struct {
		Switch token.Pos  // position of "switch" keyword
		Init   Stmt       // initialization statement; or nil
		Assign Stmt       // x := y.(type) or y.(type)
		Body   *BlockStmt // CaseClauses only
	}

	// A CommClause node represents a case of a select statement.
	CommClause struct {
		Case  token.Pos // position of "case" or "default" keyword
		Comm  Stmt      // send or receive statement; nil means default case
		Colon token.Pos // position of ":"
		Body  []Stmt    // statement list; or nil
	}

	// A SelectStmt node represents a select statement.
	SelectStmt struct {
		Select token.Pos  // position of "select" keyword
		Body   *BlockStmt // CommClauses only
	}

	// A ForStmt represents a for statement.
	ForStmt struct {
		For  token.Pos // position of "for" keyword
		Init Stmt      // initialization statement; or nil
		Cond Expr      // condition; or nil
		Post Stmt      // post iteration statement; or nil
		Body *BlockStmt
	}

	// A RangeStmt represents a for statement with a range clause.
	RangeStmt struct {
		For        token.Pos   // position of "for" keyword
		Key, Value Expr        // Key, Value may be nil
		TokPos     token.Pos   // position of Tok; invalid if Key == nil
		Tok        token.Token // ILLEGAL if Key == nil, ASSIGN, DEFINE
		X          Expr        // value to range over
		Body       *BlockStmt
	}
)

// Pos and End implementations for statement nodes.

func (s *BadStmt) Pos() token.Pos        { return s.From }
func (s *DeclStmt) Pos() token.Pos       { return s.Decl.Pos() }
func (s *EmptyStmt) Pos() token.Pos      { return s.Semicolon }
func (s *LabeledStmt) Pos() token.Pos    { return s.Label.Pos() }
func (s *ExprStmt) Pos() token.Pos       { return s.X.Pos() }
func (s *SendStmt) Pos() token.Pos       { return s.Chan.Pos() }
func (s *IncDecStmt) Pos() token.Pos     { return s.X.Pos() }
func (s *AssignStmt) Pos() token.Pos     { return s.Lhs[0].Pos() }
func (s *GoStmt) Pos() token.Pos         { return s.Go }
func (s *DeferStmt) Pos() token.Pos      { return s.Defer }
func (s *ReturnStmt) Pos() token.Pos     { return s.Return }
func (s *BranchStmt) Pos() token.Pos     { return s.TokPos }
func (s *BlockStmt) Pos() token.Pos      { return s.Lbrace }
func (s *IfStmt) Pos() token.Pos         { return s.If }
func (s *CaseClause) Pos() token.Pos     { return s.Case }
func (s *SwitchStmt) Pos() token.Pos     { return s.Switch }
func (s *TypeSwitchStmt) Pos() token.Pos { return s.Switch }
func (s *CommClause) Pos() token.Pos     { return s.Case }
func (s *SelectStmt) Pos() token.Pos     { return s.Select }
func (s *ForStmt) Pos() token.Pos        { return s.For }
func (s *RangeStmt) Pos() token.Pos      { return s.For }

func (s *BadStmt) End() token.Pos  { return s.To }
func (s *DeclStmt) End() token.Pos { return s.Decl.End() }
func (s *EmptyStmt) End() token.Pos {
	if s.Implicit {
		return s.Semicolon
	}
	return s.Semicolon + 1 /* len(";") */
}
func (s *LabeledStmt) End() token.Pos { return s.Stmt.End() }
func (s *ExprStmt) End() token.Pos    { return s.X.End() }
func (s *SendStmt) End() token.Pos    { return s.Value.End() }
func (s *IncDecStmt) End() token.Pos {
	return s.TokPos + 2 /* len("++") */
}
func (s *AssignStmt) End() token.Pos { return s.Rhs[len(s.Rhs)-1].End() }
func (s *GoStmt) End() token.Pos     { return s.Call.End() }
func (s *DeferStmt) End() token.Pos  { return s.Call.End() }
func (s *ReturnStmt) End() token.Pos {
	if n := len(s.Results); n > 0 {
		return s.Results[n-1].End()
	}
	return s.Return + 6 // len("return")
}
func (s *BranchStmt) End() token.Pos {
	if s.Label != nil {
		return s.Label.End()
	}
	return token.Pos(int(s.TokPos) + len(s.Tok.String()))
}
func (s *BlockStmt) End() token.Pos {
	if s.Rbrace.IsValid() {
		return s.Rbrace + 1
	}
	if n := len(s.List); n > 0 {
		return s.List[n-1].End()
	}
	return s.Lbrace + 1
}
func (s *IfStmt) End() token.Pos {
	if s.Else != nil {
		return s.Else.End()
	}
	return s.Body.End()
}
func (s *CaseClause) End() token.Pos {
	if n := len(s.Body); n > 0 {
		return s.Body[n-1].End()
	}
	return s.Colon + 1
}
func (s *SwitchStmt) End() token.Pos     { return s.Body.End() }
func (s *TypeSwitchStmt) End() token.Pos { return s.Body.End() }
func (s *CommClause) End() token.Pos {
	if n := len(s.Body); n > 0 {
		return s.Body[n-1].End()
	}
	return s.Colon + 1
}
func (s *SelectStmt) End() token.Pos { return s.Body.End() }
func (s *ForStmt) End() token.Pos    { return s.Body.End() }
func (s *RangeStmt) End() token.Pos  { return s.Body.End() }

// stmtNode() ensures that only statement nodes can be
// assigned to a Stmt.
func (*BadStmt) stmtNode()        {}
func (*DeclStmt) stmtNode()       {}
func (*EmptyStmt) stmtNode()      {}
func (*LabeledStmt) stmtNode()    {}
func (*ExprStmt) stmtNode()       {}
func (*SendStmt) stmtNode()       {}
func (*IncDecStmt) stmtNode()     {}
func (*AssignStmt) stmtNode()     {}
func (*GoStmt) stmtNode()         {}
func (*DeferStmt) stmtNode()      {}
func (*ReturnStmt) stmtNode()     {}
func (*BranchStmt) stmtNode()     {}
func (*BlockStmt) stmtNode()      {}
func (*IfStmt) stmtNode()         {}
func (*CaseClause) stmtNode()     {}
func (*SwitchStmt) stmtNode()     {}
func (*TypeSwitchStmt) stmtNode() {}
func (*CommClause) stmtNode()     {}
func (*SelectStmt) stmtNode()     {}
func (*ForStmt) stmtNode()        {}
func (*RangeStmt) stmtNode()      {}

// ----------------------------------------------------------------------------
// Declarations

// A Spec node represents a single (non-parenthesized) import,
// constant, type, or variable declaration.
type (
	// The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.
	Spec interface {
		Node
		specNode()
	}

	// An ImportSpec node represents a single package import.
    // 导入声明规范
	ImportSpec struct {
		Doc     *CommentGroup // associated documentation; or nil
		Name    *Ident        // local package name (including "."); or nil
		Path    *BasicLit     // import path
		Comment *CommentGroup // line comments; or nil
		EndPos  token.Pos     // end of spec (overrides Path.Pos if nonzero)
	}

	// A ValueSpec node represents a constant or variable declaration
	// (ConstSpec or VarSpec production).
	// 数值声明规范
	ValueSpec struct {
		Doc     *CommentGroup // associated documentation; or nil
		Names   []*Ident      // value names (len(Names) > 0)
		Type    Expr          // value type; or nil
		Values  []Expr        // initial values; or nil
		Comment *CommentGroup // line comments; or nil
	}

	// A TypeSpec node represents a type declaration (TypeSpec production).
    // 类型声明规范
	TypeSpec struct {
		Doc        *CommentGroup // associated documentation; or nil
		Name       *Ident        // type name
		TypeParams *FieldList    // type parameters; or nil
		Assign     token.Pos     // position of '=', if any
		Type       Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
		Comment    *CommentGroup // line comments; or nil
	}
)

// Pos and End implementations for spec nodes.

func (s *ImportSpec) Pos() token.Pos {
	if s.Name != nil {
		return s.Name.Pos()
	}
	return s.Path.Pos()
}
func (s *ValueSpec) Pos() token.Pos { return s.Names[0].Pos() }
func (s *TypeSpec) Pos() token.Pos  { return s.Name.Pos() }

func (s *ImportSpec) End() token.Pos {
	if s.EndPos != 0 {
		return s.EndPos
	}
	return s.Path.End()
}

func (s *ValueSpec) End() token.Pos {
	if n := len(s.Values); n > 0 {
		return s.Values[n-1].End()
	}
	if s.Type != nil {
		return s.Type.End()
	}
	return s.Names[len(s.Names)-1].End()
}
func (s *TypeSpec) End() token.Pos { return s.Type.End() }

// specNode() ensures that only spec nodes can be
// assigned to a Spec.
func (*ImportSpec) specNode() {}
func (*ValueSpec) specNode()  {}
func (*TypeSpec) specNode()   {}

// A declaration is represented by one of the following declaration nodes.
type (
	// A BadDecl node is a placeholder for a declaration containing
	// syntax errors for which a correct declaration node cannot be
	// created.
	//
	BadDecl struct {
		From, To token.Pos // position range of bad declaration
	}

	// A GenDecl node (generic declaration node) represents an import,
	// constant, type or variable declaration. A valid Lparen position
	// (Lparen.IsValid()) indicates a parenthesized declaration.
	//
	// Relationship between Tok value and Specs element type:
	//
	//	token.IMPORT  *ImportSpec
	//	token.CONST   *ValueSpec
	//	token.TYPE    *TypeSpec
	//	token.VAR     *ValueSpec
	//	import、常量、类型、变量声明
	GenDecl struct {
		Doc    *CommentGroup // associated documentation; or nil
		TokPos token.Pos     // position of Tok
		Tok    token.Token   // IMPORT, CONST, TYPE, or VAR
		Lparen token.Pos     // position of '(', if any
		Specs  []Spec
		Rparen token.Pos // position of ')', if any
	}

	// A FuncDecl node represents a function declaration.
    // 函数声明，包括函数名、函数签名、函数体等
	FuncDecl struct {
		Doc  *CommentGroup // associated documentation; or nil
		Recv *FieldList    // receiver (methods); or nil (functions)
		Name *Ident        // function/method name
		Type *FuncType     // function signature: type and value parameters, results, and position of "func" keyword，包括参数列表、返回值泪飙等
		Body *BlockStmt    // function body; or nil for external (non-Go) function
	}
)

// Pos and End implementations for declaration nodes.

func (d *BadDecl) Pos() token.Pos  { return d.From }
func (d *GenDecl) Pos() token.Pos  { return d.TokPos }
func (d *FuncDecl) Pos() token.Pos { return d.Type.Pos() }

func (d *BadDecl) End() token.Pos { return d.To }
func (d *GenDecl) End() token.Pos {
	if d.Rparen.IsValid() {
		return d.Rparen + 1
	}
	return d.Specs[0].End()
}
func (d *FuncDecl) End() token.Pos {
	if d.Body != nil {
		return d.Body.End()
	}
	return d.Type.End()
}

// declNode() ensures that only declaration nodes can be
// assigned to a Decl.
func (*BadDecl) declNode()  {}
func (*GenDecl) declNode()  {}
func (*FuncDecl) declNode() {}

// ----------------------------------------------------------------------------
// Files and packages

// A File node represents a Go source file.
//
// The Comments list contains all comments in the source file in order of
// appearance, including the comments that are pointed to from other nodes
// via Doc and Comment fields.
//
// For correct printing of source code containing comments (using packages
// go/format and go/printer), special care must be taken to update comments
// when a File's syntax tree is modified: For printing, comments are interspersed
// between tokens based on their position. If syntax tree nodes are
// removed or moved, relevant comments in their vicinity must also be removed
// (from the File.Comments list) or moved accordingly (by updating their
// positions). A CommentMap may be used to facilitate some of these operations.
//
// Whether and how a comment is associated with a node depends on the
// interpretation of the syntax tree by the manipulating program: Except for Doc
// and Comment comments directly associated with nodes, the remaining comments
// are "free-floating" (see also issues #18593, #20744).
type File struct {
	Doc        *CommentGroup   // associated documentation; or nil
	Package    token.Pos       // position of "package" keyword
	Name       *Ident          // package name
	Decls      []Decl          // top-level declarations; or nil，声明列表，可以用[0]、[1]这样来获取第几个声明，顺序和在源代码中是一样的
	Scope      *Scope          // package scope (this file only)
	Imports    []*ImportSpec   // imports in this file
	Unresolved []*Ident        // unresolved identifiers in this file
	Comments   []*CommentGroup // list of all comments in the source file
}

func (f *File) Pos() token.Pos { return f.Package }
func (f *File) End() token.Pos {
	if n := len(f.Decls); n > 0 {
		return f.Decls[n-1].End()
	}
	return f.Name.End()
}

// A Package node represents a set of source files
// collectively building a Go package.
type Package struct {
	Name    string             // package name
	Scope   *Scope             // package scope across all files
	Imports map[string]*Object // map of package id -> package object
	Files   map[string]*File   // Go source files by filename
}

func (p *Package) Pos() token.Pos { return token.NoPos }
func (p *Package) End() token.Pos { return token.NoPos }

// Declarations  声明

// Spec节点表示单个（无括号）导入、常量或变量、类型声明。
type (
	// The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.
	Spec interface {
		Node
		specNode()
	}

	// An ImportSpec node represents a single package import.
    // 导入声明
	ImportSpec struct {
		Doc     *CommentGroup // associated documentation; or nil
		Name    *Ident        // local package name (including "."); or nil
		Path    *BasicLit     // import path
		Comment *CommentGroup // line comments; or nil
		EndPos  token.Pos     // end of spec (overrides Path.Pos if nonzero)
	}

	// A ValueSpec node represents a constant or variable declaration
	// (ConstSpec or VarSpec production).
    // 常量或变量声明
	ValueSpec struct {
		Doc     *CommentGroup // associated documentation; or nil
		Names   []*Ident      // value names (len(Names) > 0)
		Type    Expr          // value type; or nil
		Values  []Expr        // initial values; or nil
		Comment *CommentGroup // line comments; or nil
	}

	// A TypeSpec node represents a type declaration (TypeSpec production).
    // 类型声明
	TypeSpec struct {
		Doc        *CommentGroup // associated documentation; or nil
		Name       *Ident        // type name
		TypeParams *FieldList    // type parameters; or nil
		Assign     token.Pos     // position of '=', if any
		Type       Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
		Comment    *CommentGroup // line comments; or nil
	}
)