- token
- types
token
token包定义代表Go编程语言的词法标记的常量以及对标记的基本操作（打印，谓词）。
Constants
const (
LowestPrec = 0 // non-operators
UnaryPrec = 6
HighestPrec = 7
)
一组用于基于优先级的表达式解析的常量。 非运算符的优先级最低，其后依次是从优先级1开始到一元运算符的运算符。 最高优先级用作选择器，索引以及其他运算符和定界符标记的“包罗万象”优先级。
type File
type File struct {
// contains filtered or unexported fields
}
文件是属于FileSet的文件的句柄。 文件具有名称，大小和行偏移量表。
func (*File) AddLine
func (f *File) AddLine(offset int)
AddLine为新行添加行偏移量。 行偏移量必须大于前一行的偏移量并且小于文件大小； 否则，将忽略行偏移。
func (*File) AddLineInfo
func (f *File) AddLineInfo(offset int, filename string, line int)
AddLineInfo添加给定文件偏移量的替代文件和行号信息。 偏移量必须大于先前添加的替代行信息的偏移量，并且小于文件大小； 否则，该信息将被忽略。
AddLineInfo通常用于为源文件中的// line filename：line注释注册替代位置信息。
func (*File) Base
func (f *File) Base() int
Base返回在AddFile中注册的文件f的基本偏移量。
func (*File) Line
func (f *File) Line(p Pos) int
Line返回给定文件位置p的行号； p必须是该文件或NoPos中的Pos值。
func (*File) LineCount
func (f *File) LineCount() int
LineCount返回文件f中的行数。
func (*File) MergeLine
func (f *File) MergeLine(line int)
MergeLine将一行与下一行合并。 类似于将行尾的换行符替换为空格（不更改剩余偏移量）。 要获取行号，请咨询例如 位置线 如果输入无效的行号，则MergeLine会惊慌。
func (*File) Name
func (f *File) Name() string
Name返回在AddFile中注册的文件f的文件名。
func (*File) Offset
func (f *File) Offset(p Pos) int
偏移量返回给定文件位置p的偏移量； p必须是该文件中的有效Pos值。 f.Offset（f.Pos（offset））==偏移量
func (*File) Pos
func (f *File) Pos(offset int) Pos
Pos返回给定文件偏移量的Pos值； 偏移量必须小于等于f.Size()。 f.Pos(f.Offset(p)== p。
func (*File) Position
func (f *File) Position(p Pos) (pos Position)
Position返回给定文件位置p的Position值。 调用f.Position(p)等效于调用f.PositionFor(p，true)。
func (*File) PositionFor
func (f *File) PositionFor(p Pos, adjusted bool) (pos Position)
PositionFor返回给定文件位置p的Position值。 如果设置了调整，则可以通过更改位置//注释来调整位置； 否则，这些评论将被忽略。 p必须是f或NoPos中的Pos值。
func (*File) SetLines
func (f *File) SetLines(lines []int) bool
SetLines设置文件的行偏移量，并报告文件是否成功。 行偏移量是每行第一个字符的偏移量； 例如，对于内容“ ab \ nc \ n”，行偏移量为{0，3}。 空文件的行偏移量表为空。 每行的偏移量必须大于前一行的偏移量，并且小于文件大小； 否则SetLines失败并返回false。 SetLines返回后，调用者不得更改提供的片段。
func (*File) SetLinesForContent
func (f *File) SetLinesForContent(content []byte)
SetLinesForContent设置给定文件内容的行偏移量。 它忽略更改位置的//行注释。
func (*File) Size
func (f *File) Size() int
Size返回在AddFile中注册的文件f的大小。
type FileSet
type FileSet struct {
// contains filtered or unexported fields
}
FileSet代表一组源文件。 文件集的方法是同步的； 多个goroutine可以同时调用它们。
func NewFileSet
func NewFileSet() *FileSet
NewFileSet创建一个新的文件集。
func (*FileSet) AddFile
func (s *FileSet) AddFile(filename string, base, size int) *File
AddFile将具有给定文件名，基本偏移量和文件大小的新文件添加到文件集s中，并返回该文件。 多个文件可能具有相同的名称。 基本偏移量不得小于FileSet的Base（），并且大小不得为负。 作为一种特殊情况，如果提供了一个负基数，则使用FileSet的Base（）的当前值。
添加文件会将文件集的Base（）值设置为base + size + 1，作为下一个文件的最小基本值。 给定文件偏移量的Pos值p之间存在以下关系：
int(p) = base + offs
偏移在[0，size]范围内，因此p在[base，base + size]范围内。 为了方便起见，File.Pos可用于从文件偏移量创建文件特定的位置值。
func (*FileSet) Base
func (s *FileSet) Base() int
Base返回添加下一个文件时必须提供给AddFile的最小基本偏移量。
func (*FileSet) File
func (s *FileSet) File(p Pos) (f *File)
File返回包含位置p的文件。 如果找不到此类文件（例如p == NoPos），则结果为nil。
func (*FileSet) Iterate
func (s *FileSet) Iterate(f func(*File) bool)
按照文件添加顺序对文件集中的文件重复调用f，直到f返回false为止。
func (*FileSet) Position
func (s *FileSet) Position(p Pos) (pos Position)
位置将文件集中的位置p转换为位置值。 调用s.Position(p)等效于调用s.PositionFor(p，true)。
func (*FileSet) PositionFor
func (s *FileSet) PositionFor(p Pos, adjusted bool) (pos Position)
PositionFor将文件集中的Pos p转换为Position值。 如果设置了调整，则可以通过更改位置//注释来调整位置； 否则，这些评论将被忽略。 p必须是s中的Pos值或NoPos。
func (*FileSet) Read
func (s *FileSet) Read(decode func(interface{}) error) error
读取调用解码以将文件集反序列化为s； s不能为零。
func (*FileSet) Write
func (s *FileSet) Write(encode func(interface{}) error) error
写调用编码以序列化文件集s。
type Pos
type Pos int
Pos是文件集中源位置的紧凑编码。 可以将其转换为位置，以提供更方便但更大的表示形式。
给定文件的Pos值是[base，base + size]范围内的数字，其中在将文件添加到通过AddFile设置的文件集时指定了base和size。
要为特定的源偏移量（以字节为单位）创建Pos值，请首先使用FileSet.AddFile将相应的文件添加到当前文件集中，然后对该文件调用File.Pos（offset）。 给定特定文件集fset的Pos值p，可以通过调用fset.Position（p）获得相应的Position值。
Pos值可以直接与常规比较运算符进行比较：如果两个Pos值p和q在同一文件中，则比较p和q等效于比较各自的源文件偏移量。 如果p和q位于不同的文件中，则如果p隐含的文件被添加到q隐含的文件之前的相应文件集中，则p <q为true。
const NoPos Pos = 0
Pos的零值为NoPos； 没有与之关联的文件和行信息，并且NoPos()。IsValid()为false。 NoPos始终小于任何其他Pos值。 NoPos的相应位置值是位置的零值。
func (Pos) IsValid
func (p Pos) IsValid() bool
IsValid报告位置是否有效。
type Position
type Position struct {
Filename string // filename, if any
Offset int // offset, starting at 0
Line int // line number, starting at 1
Column int // column number, starting at 1 (byte count)
}
位置描述任意源位置，包括文件，行和列的位置。 如果行号> 0，则“位置”有效。
func (*Position) IsValid
func (pos *Position) IsValid() bool
IsValid报告位置是否有效。
func (Position) String
func (pos Position) String() string
字符串以几种形式之一返回字符串：
file:line:column valid position with file name
line:column valid position without file name
file invalid position with file name
- invalid position without file name
type Token
type Token int
令牌是Go编程语言的词汇令牌的集合。
const (
// Special tokens
ILLEGAL Token = iota
EOF
COMMENT
// Identifiers and basic type literals
// (these tokens stand for classes of literals)
IDENT // main
INT // 12345
FLOAT // 123.45
IMAG // 123.45i
CHAR // 'a'
STRING // "abc"
// Operators and delimiters
ADD // +
SUB // -
MUL // *
QUO // /
REM // %
AND // &
OR // |
XOR // ^
SHL // <<
SHR // >>
AND_NOT // &^
ADD_ASSIGN // +=
SUB_ASSIGN // -=
MUL_ASSIGN // *=
QUO_ASSIGN // /=
REM_ASSIGN // %=
AND_ASSIGN // &=
OR_ASSIGN // |=
XOR_ASSIGN // ^=
SHL_ASSIGN // <<=
SHR_ASSIGN // >>=
AND_NOT_ASSIGN // &^=
LAND // &&
LOR // ||
ARROW // <-
INC // ++
DEC // --
EQL // ==
LSS // <
GTR // >
ASSIGN // =
NOT // !
NEQ // !=
LEQ // <=
GEQ // >=
DEFINE // :=
ELLIPSIS // ...
LPAREN // (
LBRACK // [
LBRACE // {
COMMA // ,
PERIOD // .
RPAREN // )
RBRACK // ]
RBRACE // }
SEMICOLON // ;
COLON // :
// Keywords
BREAK
CASE
CHAN
CONST
CONTINUE
DEFAULT
DEFER
ELSE
FALLTHROUGH
FOR
FUNC
GO
GOTO
IF
IMPORT
INTERFACE
MAP
PACKAGE
RANGE
RETURN
SELECT
STRUCT
SWITCH
TYPE
VAR
)
令牌列表。
func Lookup
func Lookup(ident string) Token
Lookup将标识符映射到其关键字标记或IDENT（如果不是关键字）。
func (Token) IsKeyword
func (tokgo Token) IsKeyword() bool
IsKeyword对于与关键字相对应的令牌返回true； 否则返回false。
func (Token) IsLiteral
func (tok Token) IsLiteral() bool
IsLiteral对于对应于标识符和基本类型文字的令牌返回true； 否则返回false。
func (Token) IsOperator
func (tok Token) IsOperator() bool
IsOperator对于与运算符和分隔符相对应的令牌返回true； 否则返回false。
func (Token) Precedence
func (op Token) Precedence() int
优先级返回二进制运算符op的运算符优先级。 如果op不是二进制运算符，则结果为LowestPrecedence。
func (Token) String
func (tok Token) String() string
String返回与令牌tok对应的字符串。 对于运算符，定界符和关键字，字符串是实际的令牌字符序列（例如，对于令牌ADD，字符串为“ +”）。 对于所有其他令牌，该字符串对应于令牌常量名称（例如，对于令牌IDENT，该字符串为“ IDENT”）。
types
types包声明数据类型并实现Go包类型检查的算法。 使用Config.Check调用包的类型检查器。 或者，使用NewChecker创建一个新的类型检查器，然后通过调用Checker.Files增量调用它。
类型检查包含几个相互依赖的阶段：
名称解析将程序中的每个标识符（ast.Ident）映射到它表示的语言对象（Object）。 使用Info。{Defs，Uses，Implicits}获取名称解析的结果。
常量折叠为作为编译时常量的每个表达式（ast.Expr）计算确切的常量值（constant.Value）。 将Info.Types [expr] .Value用于常量折叠的结果。
类型推断将计算每个表达式（ast.Expr）的类型（Type），并检查是否符合语言规范。 使用Info.Types [expr] .Type作为类型推断的结果。
有关教程，请参见https://github.com/golang/go/blob/master/s/types-tutorial。
Variables
var (
Universe *Scope
Unsafe *Package
)
var Typ = []*Basic{
Invalid: {Invalid, 0, "invalid type"},
Bool: {Bool, IsBoolean, "bool"},
Int: {Int, IsInteger, "int"},
Int8: {Int8, IsInteger, "int8"},
Int16: {Int16, IsInteger, "int16"},
Int32: {Int32, IsInteger, "int32"},
Int64: {Int64, IsInteger, "int64"},
Uint: {Uint, IsInteger | IsUnsigned, "uint"},
Uint8: {Uint8, IsInteger | IsUnsigned, "uint8"},
Uint16: {Uint16, IsInteger | IsUnsigned, "uint16"},
Uint32: {Uint32, IsInteger | IsUnsigned, "uint32"},
Uint64: {Uint64, IsInteger | IsUnsigned, "uint64"},
Uintptr: {Uintptr, IsInteger | IsUnsigned, "uintptr"},
Float32: {Float32, IsFloat, "float32"},
Float64: {Float64, IsFloat, "float64"},
Complex64: {Complex64, IsComplex, "complex64"},
Complex128: {Complex128, IsComplex, "complex128"},
String: {String, IsString, "string"},
UnsafePointer: {UnsafePointer, 0, "Pointer"},
UntypedBool: {UntypedBool, IsBoolean | IsUntyped, "untyped bool"},
UntypedInt: {UntypedInt, IsInteger | IsUntyped, "untyped int"},
UntypedRune: {UntypedRune, IsInteger | IsUntyped, "untyped rune"},
UntypedFloat: {UntypedFloat, IsFloat | IsUntyped, "untyped float"},
UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"},
UntypedString: {UntypedString, IsString | IsUntyped, "untyped string"},
UntypedNil: {UntypedNil, IsUntyped, "untyped nil"},
}
func AssertableTo
func AssertableTo(V *Interface, T Type) bool
AssertableTo报告是否可以断言类型V的值具有类型T。
func AssignableTo
func AssignableTo(V, T Type) bool
AssignableTo报告是否将类型V的值分配给类型T的变量。
func Comparable
func Comparable(T Type) bool
Comparable 报告类型T的值是否可比较。
func ConvertibleTo
func ConvertibleTo(V, T Type) bool
ConvertibleTo报告类型V的值是否可转换为类型T的值。
func DefPredeclaredTestFuncs
func DefPredeclaredTestFuncs()
DefPredeclaredTestFuncs定义断言和跟踪内置函数。 这些内置程序仅用于调试和测试此程序包。
func ExprString
func ExprString(x ast.Expr) string
ExprString返回x的（可能是简化的）字符串表示形式。
func Id
func Id(pkg *Package, name string) string
如果已导出，则Id返回名称，否则返回由包[path]限定的名称。
func Identical
func Identical(x, y Type) bool
相同的报告x和y是否相同。
func IdenticalIgnoreTags
func IdenticalIgnoreTags(x, y Type) bool
IdenticalIgnoreTags报告如果忽略标记，则x和y是否相同。
func Implements
func Implements(V Type, T *Interface) bool
Implements 报告类型V是否实现接口T。
func IsInterface
func IsInterface(typ Type) bool
IsInterface报告typ是否为接口类型。
func ObjectString
func ObjectString(obj Object, qf Qualifier) string
ObjectString返回obj的字符串形式。 限定符控制包级对象的打印，并且可以为零。
func SelectionString
func SelectionString(s *Selection, qf Qualifier) string
SelectionString返回s的字符串形式。 限定符控制包级对象的打印，并且可以为零。
func TypeString
func TypeString(typ Type, qf Qualifier) string
TypeString返回typ的字符串表示形式。 限定符控制包级对象的打印，并且可以为零。
func WriteExpr
func WriteExpr(buf *bytes.Buffer, x ast.Expr)
WriteExpr将x的（可能是简化的）字符串表示形式写入buf。
func WriteSignature
func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier)
WriteSignature将签名sig的表示形式写入buf，而没有前导“ func”关键字。 限定符控制包级对象的打印，并且可以为零。
func WriteType
func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier)
WriteType将typ的字符串表示形式写入buf。 限定符控制包级对象的打印，并且可以为零。
type Array
type Array struct {
// contains filtered or unexported fields
}
Array表示数组类型。
func NewArray
func NewArray(elem Type, len int64) *Array
NewArray返回给定元素类型和长度的新数组类型。
func (*Array) Elem
func (a *Array) Elem() Type
Elem返回数组a的元素类型。
func (*Array) Len
func (a *Array) Len() int64
Len返回数组a的长度。
func (*Array) String
func (t *Array) String() string
func (*Array) Underlying
func (t *Array) Underlying() Type
type Basic
type Basic struct {
// contains filtered or unexported fields
}
Basic表示基本类型。
func (*Basic) Info
func (b *Basic) Info() BasicInfo
Info返回有关基本类型b的属性的信息。
func (*Basic) Kind
func (b *Basic) Kind() BasicKind
Kind返回基本类型b的类型。
func (*Basic) Name
func (b *Basic) Name() string
Name返回基本类型b的名称。
func (*Basic) String
func (t *Basic) String() string
func (*Basic) Underlying
func (t *Basic) Underlying() Type
type BasicInfo
type BasicInfo int
BasicInfo是一组描述基本类型属性的标志。
const (
IsBoolean BasicInfo = 1 << iota
IsInteger
IsUnsigned
IsFloat
IsComplex
IsString
IsUntyped
IsOrdered = IsInteger | IsFloat | IsString
IsNumeric = IsInteger | IsFloat | IsComplex
IsConstType = IsBoolean | IsNumeric | IsString
)
基本类型的属性。
type BasicKind
type BasicKind int
BasicKind描述基本类型的种类。
const (
Invalid BasicKind = iota // type is invalid
// predeclared types
Bool
Int
Int8
Int16
Int32
Int64
Uint
Uint8
Uint16
Uint32
Uint64
Uintptr
Float32
Float64
Complex64
Complex128
String
UnsafePointer
// types for untyped values
UntypedBool
UntypedInt
UntypedRune
UntypedFloat
UntypedComplex
UntypedString
UntypedNil
// aliases
Byte = Uint8
Rune = Int32
)
type Builtin
type Builtin struct {
// contains filtered or unexported fields
}
Builtin表示内置功能。 Builtins没有有效的类型。
func (*Builtin) Exported
func (obj *Builtin) Exported() bool
func (*Builtin) Id
func (obj *Builtin) Id() string
func (*Builtin) Name
func (obj *Builtin) Name() string
func (*Builtin) Parent
func (obj *Builtin) Parent() *Scope
func (*Builtin) Pkg
func (obj *Builtin) Pkg() *Package
func (*Builtin) Pos
func (obj *Builtin) Pos() token.Pos
func (*Builtin) String
func (obj *Builtin) String() string
func (*Builtin) Type
func (obj *Builtin) Type() Type
type Chan
type Chan struct {
// contains filtered or unexported fields
}
Chan代表渠道类型。
func NewChan
func NewChan(dir ChanDir, elem Type) *Chan
NewChan返回给定方向和元素类型的新通道类型。
func (*Chan) Dir
func (c *Chan) Dir() ChanDir
Dir返回通道c的方向。
func (*Chan) Elem
func (c *Chan) Elem() Type
Elem返回通道c的元素类型。
func (*Chan) String
func (t *Chan) String() string
func (*Chan) Underlying
func (t *Chan) Underlying() Type
type ChanDir
type ChanDir int
ChanDir值指示通道方向。
const (
SendRecv ChanDir = iota
SendOnly
RecvOnly
)
通道的方向由这些常数之一指示。
type Checker
type Checker struct {
*Info
// contains filtered or unexported fields
}
检查器维护类型检查器的状态。 必须使用NewChecker创建它。
func NewChecker
func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Checker
NewChecker返回给定包的新Checker实例。 软件包文件可以通过checker.Files增量添加。
func (*Checker) Files
func (check *Checker) Files(files []*ast.File) error
文件检查作为检查程序包一部分的提供的文件。
type Config
type Config struct {
// If IgnoreFuncBodies is set, function bodies are not
// type-checked.
IgnoreFuncBodies bool
// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
// declares an empty "C" package and errors are omitted for qualified
// identifiers referring to package C (which won't find an object).
// This feature is intended for the standard library cmd/api tool.
//
// Caution: Effects may be unpredictable due to follow-up errors.
// Do not use casually!
FakeImportC bool
// If Error != nil, it is called with each error found
// during type checking; err has dynamic type Error.
// Secondary errors (for instance, to enumerate all types
// involved in an invalid recursive type declaration) have
// error strings that start with a '\t' character.
// If Error == nil, type-checking stops with the first
// error found.
Error func(err error)
// An importer is used to import packages referred to from
// import declarations.
// If the installed importer implements ImporterFrom, the type
// checker calls ImportFrom instead of Import.
// The type checker reports an error if an importer is needed
// but none was installed.
Importer Importer
// If Sizes != nil, it provides the sizing functions for package unsafe.
// Otherwise &StdSizes{WordSize: 8, MaxAlign: 8} is used instead.
Sizes Sizes
// If DisableUnusedImportCheck is set, packages are not checked
// for unused imports.
DisableUnusedImportCheck bool
}
Config指定用于类型检查的配置。 Config的零值是随时可用的默认配置。
func (*Config) Check
func (conf *Config) Check(path string, fset *token.FileSet, files []*ast.File, info *Info) (*Package, error)
Check对包进行类型检查，并返回生成的包对象和第一个错误（如果有）。 此外，如果info！= nil，则Check将填充Info结构中的每个非nil映射。
如果没有发生错误，则该程序包将标记为已完成，否则为不完整。 有关在出现错误时控制行为的信息，请参见Config.Error。
该包由* ast.Files和相应文件集的列表指定，并且标识了该软件包所使用的包[path]。 干净路径不能为空或点（“。”）。
type Const
type Const struct {
// contains filtered or unexported fields
}
常量代表声明的常量。
func NewConst
func NewConst(pos token.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const
func (*Const) Exported
func (obj *Const) Exported() bool
func (*Const) Id
func (obj *Const) Id() string
func (*Const) Name
func (obj *Const) Name() string
func (*Const) Parent
func (obj *Const) Parent() *Scope
func (*Const) Pkg
func (obj *Const) Pkg() *Package
func (*Const) Pos
func (obj *Const) Pos() token.Pos
func (*Const) String
func (obj *Const) String() string
func (*Const) Type
func (obj *Const) Type() Type
func (*Const) Val
func (obj *Const) Val() constant.Value
type Error
type Error struct {
Fset *token.FileSet // file set for interpretation of Pos
Pos token.Pos // error position
Msg string // error message
Soft bool // if set, error is "soft"
}
错误描述类型检查错误。 它实现了错误接口。 “软”错误是仍然允许对包进行有效解释的错误（例如“未使用的变量”）； 如果忽略“硬”错误，可能会导致无法预测的行为。
func (Error) Error
func (err Error) Error() string
错误返回错误字符串，其格式如下：filename：line：column：message
type Func
type Func struct {
// contains filtered or unexported fields
}
Func代表声明的函数，具体方法或抽象（接口）方法。 它的Type（）始终是* Signature。 由于嵌入，抽象方法可能属于许多接口。
func MissingMethod
func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool)
如果V实现T，则MissingMethod返回（nil，false），否则返回T所需的缺少方法，以及它是否丢失或类型错误。
对于非接口类型V，或者如果设置了static，则如果V中存在T的所有方法，则V实现T。否则（V是接口并且未设置静态），MissingMethod仅检查是否存在T的方法 在V中具有匹配的类型（例如，对于类型断言x。（T），其中x为接口类型V）。
func NewFunc
func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func
func (*Func) Exported
func (obj *Func) Exported() bool
func (*Func) FullName
func (obj *Func) FullName() string
FullName返回函数或方法obj的包或接收者类型限定的名称。
func (*Func) Id
func (obj *Func) Id() string
func (*Func) Name
func (obj *Func) Name() string
func (*Func) Parent
func (obj *Func) Parent() *Scope
func (*Func) Pkg
func (obj *Func) Pkg() *Package
func (*Func) Pos
func (obj *Func) Pos() token.Pos
func (*Func) Scope
func (obj *Func) Scope() *Scope
func (*Func) String
func (obj *Func) String() string
func (*Func) Type
func (obj *Func) Type() Type
type ImportMode
type ImportMode int
ImportMode保留供将来使用。
type Importer
type Importer interface {
// Import returns the imported package for the given import
// path, or an error if the package couldn't be imported.
// Two calls to Import with the same path return the same
// package.
Import(path string) (*Package, error)
}
Importer解析程序包的导入路径。
注意：此界面不支持导入本地供应的软件包。 参见https://github.com/golang/go/blob/master/s/go15vendor。 如果可能，外部实现应实现ImporterFrom。
type ImporterFrom
type ImporterFrom interface {
// Importer is present for backward-compatibility. Calling
// Import(path) is the same as calling ImportFrom(path, "", 0);
// i.e., locally vendored packages may not be found.
// The types package does not call Import if an ImporterFrom
// is present.
Importer
// ImportFrom returns the imported package for the given import
// path when imported by the package in srcDir, or an error
// if the package couldn't be imported. The mode value must
// be 0; it is reserved for future use.
// Two calls to ImportFrom with the same path and srcDir return
// the same package.
ImportFrom(path, srcDir string, mode ImportMode) (*Package, error)
}
ImporterFrom解析包的导入路径； 它支持根据https://github.com/golang/go/blob/master/s/go15vendor进行销售。 使用go / importer获取ImporterFrom实现。
type Info
type Info struct {
// Types maps expressions to their types, and for constant
// expressions, also their values. Invalid expressions are
// omitted.
//
// For (possibly parenthesized) identifiers denoting built-in
// functions, the recorded signatures are call-site specific:
// if the call result is not a constant, the recorded type is
// an argument-specific signature. Otherwise, the recorded type
// is invalid.
//
// The Types map does not record the type of every identifier,
// only those that appear where an arbitrary expression is
// permitted. For instance, the identifier f in a selector
// expression x.f is found only in the Selections map, the
// identifier z in a variable declaration 'var z int' is found
// only in the Defs map, and identifiers denoting packages in
// qualified identifiers are collected in the Uses map.
Types map[ast.Expr]TypeAndValue
// Defs maps identifiers to the objects they define (including
// package names, dots "." of dot-imports, and blank "_" identifiers).
// For identifiers that do not denote objects (e.g., the package name
// in package clauses, or symbolic variables t in t := x.(type) of
// type switch headers), the corresponding objects are nil.
//
// For an anonymous field, Defs returns the field *Var it defines.
//
// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
Defs map[*ast.Ident]Object
// Uses maps identifiers to the objects they denote.
//
// For an anonymous field, Uses returns the *TypeName it denotes.
//
// Invariant: Uses[id].Pos() != id.Pos()
Uses map[*ast.Ident]Object
// Implicits maps nodes to their implicitly declared objects, if any.
// The following node and object types may appear:
//
// node declared object
//
// *ast.ImportSpec *PkgName for dot-imports and imports without renames
// *ast.CaseClause type-specific *Var for each type switch case clause (incl. default)
// *ast.Field anonymous parameter *Var
//
Implicits map[ast.Node]Object
// Selections maps selector expressions (excluding qualified identifiers)
// to their corresponding selections.
Selections map[*ast.SelectorExpr]*Selection
// Scopes maps ast.Nodes to the scopes they define. Package scopes are not
// associated with a specific node but with all files belonging to a package.
// Thus, the package scope can be found in the type-checked Package object.
// Scopes nest, with the Universe scope being the outermost scope, enclosing
// the package scope, which contains (one or more) files scopes, which enclose
// function scopes which in turn enclose statement and function literal scopes.
// Note that even though package-level functions are declared in the package
// scope, the function scopes are embedded in the file scope of the file
// containing the function declaration.
//
// The following node types may appear in Scopes:
//
// *ast.File
// *ast.FuncType
// *ast.BlockStmt
// *ast.IfStmt
// *ast.SwitchStmt
// *ast.TypeSwitchStmt
// *ast.CaseClause
// *ast.CommClause
// *ast.ForStmt
// *ast.RangeStmt
//
Scopes map[ast.Node]*Scope
// InitOrder is the list of package-level initializers in the order in which
// they must be executed. Initializers referring to variables related by an
// initialization dependency appear in topological order, the others appear
// in source order. Variables without an initialization expression do not
// appear in this list.
InitOrder []*Initializer
}
Info保存Type检查包的结果类型信息。 仅收集提供地图的信息。 如果程序包有类型错误，则收集的信息可能不完整。
func (*Info) ObjectOf
func (info *Info) ObjectOf(id *ast.Ident) Object
ObjectOf返回由指定的id表示的对象；如果找不到，则返回nil。
如果id是匿名结构字段，则ObjectOf返回其使用的字段（* Var），而不是其定义的类型（* TypeName）。
前提条件：已使用和定义地图。
func (*Info) TypeOf
func (info *Info) TypeOf(e ast.Expr) Type
TypeOf返回表达式e的类型；如果未找到，则返回nil。 前提条件：类型，用途和定义图已填充。
type Initializer
type Initializer struct {
Lhs []*Var // var Lhs = Rhs
Rhs ast.Expr
}
初始化程序描述程序包级别的变量，或在多值初始化表达式的情况下的变量列表，以及相应的初始化表达式。
func (*Initializer) String
func (init *Initializer) String() string
type Interface
type Interface struct {
// contains filtered or unexported fields
}
Interface表示接口类型。
func NewInterface
func NewInterface(methods []*Func, embeddeds []*Named) *Interface
NewInterface返回给定方法和嵌入类型的新接口。
func (*Interface) Complete
func (t *Interface) Complete() *Interface
Complete计算接口的方法集。 在完全定义了接口的嵌入式类型之后，以及以除形成其他类型之外的任何其他方式使用接口类型之前，NewInterface的用户必须调用它。 完成返回接收者。
func (*Interface) Embedded
func (t *Interface) Embedded(i int) *Named
对于0 <= i <t.NumEmbeddeds()，Embedded返回接口t的第i个嵌入式类型。 类型由对应的TypeName的唯一ID排序。
func (*Interface) Empty
func (t *Interface) Empty() bool
如果t为空接口，则Empty返回true。
func (*Interface) ExplicitMethod
func (t *Interface) ExplicitMethod(i int) *Func
ExplicitMethod返回接口t的第i个显式声明的方法，其取值为0 <= i <t.NumExplicitMethods()。 这些方法按其唯一ID排序。
func (*Interface) Method
func (t *Interface) Method(i int) *Func
方法为0 <= i <t.NumMethods()返回接口t的第i个方法。 这些方法按其唯一ID排序。
func (*Interface) NumEmbeddeds
func (t *Interface) NumEmbeddeds() int
NumEmbeddeds返回接口t中嵌入类型的数量。
func (*Interface) NumExplicitMethods
func (t *Interface) NumExplicitMethods() int
NumExplicitMethods返回接口t的显式声明的方法的数量。
func (*Interface) NumMethods
func (t *Interface) NumMethods() int
NumMethods返回接口t的方法总数。
func (*Interface) String
func (t *Interface) String() string
func (*Interface) Underlying
func (t *Interface) Underlying() Type
type Label
type Label struct {
// contains filtered or unexported fields
}
Label代表声明的标签。
func NewLabel
func NewLabel(pos token.Pos, pkg *Package, name string) *Label
func (*Label) Exported
func (obj *Label) Exported() bool
func (*Label) Id
func (obj *Label) Id() string
func (*Label) Name
func (obj *Label) Name() string
func (*Label) Parent
func (obj *Label) Parent() *Scope
func (*Label) Pkg
func (obj *Label) Pkg() *Package
func (*Label) Pos
func (obj *Label) Pos() token.Pos
func (*Label) String
func (obj *Label) String() string
func (*Label) Type
func (obj *Label) Type() Type
type Map
type Map struct {
// contains filtered or unexported fields
}
Map 代表map类型。
func NewMap
func NewMap(key, elem Type) *Map
NewMap返回给定键和元素类型的新映射。
func (*Map) Elem
func (m *Map) Elem() Type
Elem返回映射m的元素类型。
func (*Map) Key
func (m *Map) Key() Type
Key返回映射m的键类型。
func (*Map) String
func (t *Map) String() string
func (*Map) Underlying
func (t *Map) Underlying() Type
type MethodSet
type MethodSet struct {
// contains filtered or unexported fields
}
MethodSet是具体或抽象（接口）方法的有序集合。 方法是MethodVal选择，它们通过将m.Obj（）。Id（）升序进行排序。 MethodSet的零值为可立即使用的空方法集。
func NewMethodSet
func NewMethodSet(T Type) *MethodSet
NewMethodSet返回给定类型T的方法集。即使它为空，也总是返回非null的方法集。
func (*MethodSet) At
func (s *MethodSet) At(i int) *Selection
At返回0中的第i个方法，其中0 <= i <s.Len（）。
func (*MethodSet) Len
func (s *MethodSet) Len() int
Len返回以s为单位的方法数。
func (*MethodSet) Lookup
func (s *MethodSet) Lookup(pkg *Package, name string) *Selection
Lookup将返回具有匹配包和名称的方法，如果找不到，则返回nil。
func (*MethodSet) String
func (s *MethodSet) String() string
type Named
type Named struct {
// contains filtered or unexported fields
}
Named表示命名类型。
func NewNamed
func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named
NewNamed返回给定类型名称，基础类型和关联方法的新命名类型。 基础类型不能为* Named。
func (*Named) AddMethod
func (t *Named) AddMethod(m *Func)
AddMethod会添加方法m，除非它已经在方法列表中。 TODO（gri）找到了一个更好的解决方案，而不是提供此功能。
func (*Named) Method
func (t *Named) Method(i int) *Func
方法返回0 <= i <t.NumMethods（）的第i个命名类型为t的方法。
func (*Named) NumMethods
func (t *Named) NumMethods() int
NumMethods返回其接收者称为类型t的显式方法的数量。
func (*Named) Obj
func (t *Named) Obj() *TypeName
TypeName返回命名类型t的类型名称。
func (*Named) SetUnderlying
func (t *Named) SetUnderlying(underlying Type)
SetUnderlying设置基础类型并将t标记为完成。 TODO（gri）确定是否有比提供此功能更好的解决方案
func (*Named) String
func (t *Named) String() string
func (*Named) Underlying
func (t *Named) Underlying() Type
type Nil
type Nil struct {
// contains filtered or unexported fields
}
Nil代表预设值nil。
func (*Nil) Exported
func (obj *Nil) Exported() bool
func (*Nil) Id
func (obj *Nil) Id() string
func (*Nil) Name
func (obj *Nil) Name() string
func (*Nil) Parent
func (obj *Nil) Parent() *Scope
func (*Nil) Pkg
func (obj *Nil) Pkg() *Package
func (*Nil) Pos
func (obj *Nil) Pos() token.Pos
func (*Nil) String
func (obj *Nil) String() string
func (*Nil) Type
func (obj *Nil) Type() Type
type Object
type Object interface {
Parent() *Scope // scope in which this object is declared; nil for methods and struct fields
Pos() token.Pos // position of object identifier in declaration
Pkg() *Package // nil for objects in the Universe scope and labels
Name() string // package local object name
Type() Type // object type
Exported() bool // reports whether the name starts with a capital letter
Id() string // object id (see Id below)
// String returns a human-readable string of the object.
String() string
// contains filtered or unexported methods
}
Object描述命名的语言实体，例如包，常量，类型，变量，函数（包括方法）或标签。 所有对象都实现对象接口。
func LookupFieldOrMethod
func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool)
LookupFieldOrMethod在T中查找具有给定包和名称的字段或方法，并返回相应的* Var或* Func，索引序列和一个布尔值，指示在指向该字段或方法的路径上是否存在任何指针间接方式。 如果设置了可寻址，则T是可寻址变量的类型（仅对方法查找有用）。
最后一个索引条目是找到条目的（可能是嵌入的）类型的字段或方法索引，可以是：
1) the list of declared methods of a named type; or
2) the list of all methods (method set) of an interface type; or
3) the list of fields of a struct type.
较早的索引条目是从深度0开始遍历以到达找到的条目的匿名struct字段的索引。
如果未找到任何条目，则返回nil对象。 在这种情况下，返回的索引和间接值具有以下含义：
- If index != nil, the index sequence points to an ambiguous entry
(the same name appeared more than once at the same embedding level).
- If indirect is set, a method with a pointer receiver type was found
but there was no pointer on the path from the actual receiver type to
the method's formal receiver base type, nor was the receiver addressable.
type Package
type Package struct {
// contains filtered or unexported fields
}
Package 包描述了Go包。
func NewPackage
func NewPackage(path, name string) *Package
NewPackage为给定的包path和名称返回一个新Package； 名称不能为空白标识符。 程序包不完整，不包含任何显式导入。
func (*Package) Complete
func (pkg *Package) Complete() bool
如果包的范围包含（至少）所有导出的对象，则该包是完整的； 否则不完整。
func (*Package) Imports
func (pkg *Package) Imports() []*Package
Imports返回由pkg直接导入的软件包列表。 该列表按源顺序排列。 包不安全的除外。
如果pkg是从导出数据加载的，则Imports包含的软件包将提供pkg引用的软件包级别的对象。 这可能比pkg的源代码直接导入的软件包集更多或更少。
func (*Package) MarkComplete
func (pkg *Package) MarkComplete()
MarkComplete将包标记为完整。
func (*Package) Name
func (pkg *Package) Name() string
Name返回程序包名称。
func (*Package) Path
func (pkg *Package) Path() string
Path返回包 path.
func (*Package) Scope
func (pkg *Package) Scope() *Scope
Scope返回（完整或不完整）包范围，其中包含在包级别声明的对象（TypeNames，Consts，Var和Funcs）。
func (*Package) SetImports
func (pkg *Package) SetImports(list []*Package)
SetImports将明确导入的软件包的列表设置为list。 确保列表元素是唯一的是调用者的责任。
func (*Package) SetName
func (pkg *Package) SetName(name string)
SetName设置程序包名称。
func (*Package) String
func (pkg *Package) String() string
type PkgName
type PkgName struct {
// contains filtered or unexported fields
}
PkgName表示导入的Go软件包。
func NewPkgName
func NewPkgName(pos token.Pos, pkg *Package, name string, imported *Package) *PkgName
func (*PkgName) Exported
func (obj *PkgName) Exported() bool
func (*PkgName) Id
func (obj *PkgName) Id() string
func (*PkgName) Imported
func (obj *PkgName) Imported() *Package
Imported返回导入的包。 它不同于Pkg（），后者是包含import语句的程序包。
func (*PkgName) Name
func (obj *PkgName) Name() string
func (*PkgName) Parent
func (obj *PkgName) Parent() *Scope
func (*PkgName) Pkg
func (obj *PkgName) Pkg() *Package
func (*PkgName) Pos
func (obj *PkgName) Pos() token.Pos
func (*PkgName) String
func (obj *PkgName) String() string
func (*PkgName) Type
func (obj *PkgName) Type() Type
type Pointer
type Pointer struct {
// contains filtered or unexported fields
}
Pointer表示指针类型。
func NewPointer
func NewPointer(elem Type) *Pointer
NewPointer返回给定元素（基本）类型的新指针类型。
func (*Pointer) Elem
func (p *Pointer) Elem() Type
Elem返回给定指针p的元素类型。
func (*Pointer) String
func (t *Pointer) String() string
func (*Pointer) Underlying
func (t *Pointer) Underlying() Type
type Qualifier
type Qualifier func(*Package) string
Qualifier控制在对TypeString，ObjectString和SelectionString的调用中如何打印已命名的包级对象。
这三个格式化例程会为每个程序包级对象O调用Qualifier，如果Qualifier返回非空字符串p，则该对象将以p.O的形式打印。 如果返回空字符串，则仅打印对象名称O。
使用nil限定符等同于使用（* Package）.Path：对象由导入路径限定，例如“ encoding / json.Marshal”。
func RelativeTo
func RelativeTo(pkg *Package) Qualifier
RelativeTo（pkg）返回一个限定符，该限定符完全限定除pkg之外的所有包的成员。
type Scope
type Scope struct {
// contains filtered or unexported fields
}
范围维护一组对象，并链接到其包含（父）范围和包含（子）范围。 可以插入对象并按名称查找。 范围的零值是即用型空范围。
func NewScope
func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope
NewScope返回给定父范围（如果有）中包含的新的空范围。 该注释仅用于调试。
func (*Scope) Child
func (s *Scope) Child(i int) *Scope
子级返回0 <= i <NumChildren（）的第i个子级范围。
func (*Scope) Contains
func (s *Scope) Contains(pos token.Pos) bool
如果pos在范围之内，则包含返回true。 仅当类型检查的AST具有完整的位置信息时，才能保证结果有效。
func (*Scope) End
func (s *Scope) End() token.Pos
func (*Scope) Innermost
func (s *Scope) Innermost(pos token.Pos) *Scope
最内层返回包含pos的最内层（子范围）。 如果pos不在任何范围内，则结果为nil。 对于Universe范围，结果也为零。 仅当类型检查的AST具有完整的位置信息时，才能保证结果有效。
func (*Scope) Insert
func (s *Scope) Insert(obj Object) Object
插入尝试将对象obj插入范围s中。 如果s已经包含同名的替代对象alt，则Insert会使s保持不变，并返回alt。 否则，它将插入obj，设置该对象的父范围（如果尚未设置），然后返回nil。
func (*Scope) Len
func (s *Scope) Len() int
Len（）返回范围元素的数量。
func (*Scope) Lookup
func (s *Scope) Lookup(name string) Object
如果存在这样的对象，则Lookup返回具有给定名称的作用域s中的对象； 否则结果为零。
func (*Scope) LookupParent
func (s *Scope) LookupParent(name string, pos token.Pos) (*Scope, Object)
LookupParent遵循以s开头的范围的父级链，直到找到其中Lookup（name）返回非nil对象的范围，然后返回该范围和对象的范围。 如果提供了有效位置pos，则仅考虑在pos或之前声明的对象。 如果不存在这样的范围和对象，则结果为（nil，nil）。
请注意，如果将对象插入到作用域中并且当时已经有一个父对象，则obj.Parent（）可能与返回的作用域不同（请参见下面的插入）。 这仅适用于点导入对象，其范围是导出它们的包的范围。
func (*Scope) Names
func (s *Scope) Names() []string
名称按排序顺序返回范围的元素名称。
func (*Scope) NumChildren
func (s *Scope) NumChildren() int
NumChildren（）返回嵌套在s中的范围数。
func (*Scope) Parent
func (s *Scope) Parent() *Scope
父级返回范围的包含（父级）范围。
func (*Scope) Pos
func (s *Scope) Pos() token.Pos
Pos和End描述了范围的源代码范围[pos，end）。 仅当类型检查的AST具有完整的位置信息时，才能保证结果有效。 对于Universe和包范围，范围未定义。
func (*Scope) String
func (s *Scope) String() string
String返回范围的字符串表示形式，以进行调试。
func (*Scope) WriteTo
func (s *Scope) WriteTo(w io.Writer, n int, recurse bool)
WriteTo将范围的字符串表示形式写入w，范围元素按名称排序。 压痕级别由n> = 0控制，其中n == 0表示无压痕。 如果设置了递归，它还将写入嵌套（子级）作用域。
type Selection
type Selection struct {
// contains filtered or unexported fields
}
选择描述选择器表达式x.f。 对于声明：
type T struct{ x int; E }
type E struct{}
func (e E) m() {}
var p *T
存在以下关系：
Selector Kind Recv Obj Type Index Indirect
p.x FieldVal T x int {0} true
p.m MethodVal *T m func (e *T) m() {1, 0} true
T.m MethodExpr T m func m(_ T) {1, 0} false
func (*Selection) Index
func (s *Selection) Index() []int
索引描述x.f中从x到f的路径。 最后一个索引条目是声明f的类型的字段或方法索引； 要么：
1) the list of declared methods of a named type; or
2) the list of methods of an interface type; or
3) the list of fields of a struct type.
较早的索引条目是从嵌入深度0开始隐式遍历以从（x的类型）到f的嵌入字段的索引。
func (*Selection) Indirect
func (s *Selection) Indirect() bool
Indirect报告是否需要任何指针间接以从x.f中的x到达f。
func (*Selection) Kind
func (s *Selection) Kind() SelectionKind
Kind 返回选择种类。
func (*Selection) Obj
func (s *Selection) Obj() Object
Obj返回由x.f表示的对象； * Var用于字段选择，* Func用于所有其他情况。
func (*Selection) Recv
func (s *Selection) Recv() Type
Recv返回x.f中x的类型。
func (*Selection) String
func (s *Selection) String() string
func (*Selection) Type
func (s *Selection) Type() Type
Type返回x.f的类型，该类型可能与f。的类型不同。 有关更多信息，请参见选择。
type SelectionKind
type SelectionKind int
SelectionKind描述选择器表达式x.f的类型（不包括合格标识符）。
const (
FieldVal SelectionKind = iota // x.f is a struct field selector
MethodVal // x.f is a method selector
MethodExpr // x.f is a method expression
)
type Signature
type Signature struct {
// contains filtered or unexported fields
}
Signature 表示（非内置）函数或方法类型。
func NewSignature
func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature
NewSignature为给定的接收器，参数和结果返回一个新的函数类型，其中任何一个都不为零。 如果设置了可变参数，则该函数为可变参数，它必须至少具有一个参数，并且最后一个参数必须为未命名切片类型。
func (*Signature) Params
func (s *Signature) Params() *Tuple
Params 返回签名s的参数或nil。
func (*Signature) Recv
func (s *Signature) Recv() *Var
Recv返回签名s的接收者（如果是方法），或者返回nil（如果是函数）。
对于抽象方法，Recv以* Named或* Interface返回封闭的接口。 由于嵌入，接口可能包含其接收者类型为不同接口的方法。
func (*Signature) Results
func (s *Signature) Results() *Tuple
Results返回签名s的结果，即nil。
func (*Signature) String
func (t *Signature) String() string
func (*Signature) Underlying
func (t *Signature) Underlying() Type
func (*Signature) Variadic
func (s *Signature) Variadic() bool
可变参数报告签名s是否可变。
type Sizes
type Sizes interface {
// Alignof returns the alignment of a variable of type T.
// Alignof must implement the alignment guarantees required by the spec.
Alignof(T Type) int64
// Offsetsof returns the offsets of the given struct fields, in bytes.
// Offsetsof must implement the offset guarantees required by the spec.
Offsetsof(fields []*Var) []int64
// Sizeof returns the size of a variable of type T.
// Sizeof must implement the size guarantees required by the spec.
Sizeof(T Type) int64
}
Sizes 定义了包装的大小调整功能 unsafe.
type Slice
type Slice struct {
// contains filtered or unexported fields
}
Slice 表示切片类型。
func NewSlice
func NewSlice(elem Type) *Slice
NewSlice返回给定元素类型的新切片类型。
func (*Slice) Elem
func (s *Slice) Elem() Type
Elem返回slice的元素类型。
func (*Slice) String
func (t *Slice) String() string
func (*Slice) Underlying
func (t *Slice) Underlying() Type
type StdSizes
type StdSizes struct {
WordSize int64 // word size in bytes - must be >= 4 (32bits)
MaxAlign int64 // maximum alignment in bytes - must be >= 1
}
StdSizes是用于创建常用大小的一种便利类型。 它做出以下简化假设：
- The size of explicitly sized basic types (int16, etc.) is the
specified size.
- The size of strings and interfaces is 2*WordSize.
- The size of slices is 3*WordSize.
- The size of an array of n elements corresponds to the size of
a struct of n consecutive fields of the array's element type.
- The size of a struct is the offset of the last field plus that
field's size. As with all element types, if the struct is used
in an array its size must first be aligned to a multiple of the
struct's alignment.
- All other types have size WordSize.
- Arrays and structs are aligned per spec definition; all other
types are naturally aligned with a maximum alignment MaxAlign.
- StdSizes实现Sizes。
func (*StdSizes) Alignof
func (s *StdSizes) Alignof(T Type) int64
func (*StdSizes) Offsetsof
func (s *StdSizes) Offsetsof(fields []*Var) []int64
func (*StdSizes) Sizeof
func (s *StdSizes) Sizeof(T Type) int64
type Struct
type Struct struct {
// contains filtered or unexported fields
}
Struct表示结构类型。
func NewStruct
func NewStruct(fields []*Var, tags []string) *Struct
NewStruct返回具有给定字段和相应字段标签的新结构。 如果索引为i的字段具有标签，则tag [i]必须是该标签，但是len（tags）的长度可能只有保存索引最大i的标签所需的时间。 因此，如果没有字段具有标签，则标签可能为零。
func (*Struct) Field
func (s *Struct) Field(i int) *Var
Field returns the i'th field for 0 <= i < NumFields().
func (*Struct) NumFields
func (s *Struct) NumFields() int
NumFields返回第0个i = N <NumFields（）的第i个字段。
func (*Struct) String
func (t *Struct) String() string
func (*Struct) Tag
func (s *Struct) Tag(i int) string
Tag返回第i个字段标签，其值为0 <= i <NumFields（）。
func (*Struct) Underlying
func (t *Struct) Underlying() Type
type Tuple
type Tuple struct {
// contains filtered or unexported fields
}
元组表示变量的有序列表； nil *元组是有效的（空）元组。 元组用作签名的组成部分，并表示多个分配的类型； 他们不是围棋的头等舱类型。
func NewTuple
func NewTuple(x ...*Var) *Tuple
NewTuple返回给定变量的新元组。
func (*Tuple) At
func (t *Tuple) At(i int) *Var
At返回元组t的第i个变量。
func (*Tuple) Len
func (t *Tuple) Len() int
Len返回元组t的数字变量。
func (*Tuple) String
func (t *Tuple) String() string
func (*Tuple) Underlying
func (t *Tuple) Underlying() Type
type Type
type Type interface {
// Underlying returns the underlying type of a type.
Underlying() Type
// String returns a string representation of a type.
String() string
}
Type 类型表示Go的类型。 所有类型都实现Type接口。
func Default
func Default(typ Type) Type
Default为“无类型”类型返回默认的“有类型”类型； 它返回所有其他类型的传入类型。 无类型nil的默认类型为无类型nil。
type TypeAndValue
type TypeAndValue struct {
Type Type
Value constant.Value
// contains filtered or unexported fields
}
TypeAndValue报告相应表达式的类型和值（用于常量）。
func Eval
func Eval(fset *token.FileSet, pkg *Package, pos token.Pos, expr string) (TypeAndValue, error)
Eval返回类型，如果为常数，则返回在包pkg位置pos处计算的expr表达式的值，该值必须是通过对AST进行类型检查并使用相对于所提供文件集的完整位置信息得出的。
如果表达式包含函数文字，则会忽略其主体（即，不对主体进行类型检查）。
如果pkg == nil，则使用Universe范围，并且忽略提供的位置pos。如果pkg！= nil，而pos无效，则使用包范围。否则，pos必须属于该软件包。
如果pos不在软件包中，或者无法评估该节点，则返回错误。
注意：除了运行Check之外，不应使用Eval代替运行Check来计算类型和值。 Eval每次都会重新评估其参数，并且它也不知道使用表达式的上下文（例如，赋值）。因此，顶级无类型常量将返回无类型类型，而不是相应的上下文特定类型。
func (TypeAndValue) Addressable
func (tv TypeAndValue) Addressable() bool
可寻址报告了相应的表达式是否可寻址（https://github.com/golang/go/blob/master/ref/spec#Address_operators）。
func (TypeAndValue) Assignable
func (tv TypeAndValue) Assignable() bool
Assignable 报告相应的表达式是否可分配给（提供正确类型的值）。
func (TypeAndValue) HasOk
func (tv TypeAndValue) HasOk() bool
HasOk报告是否可以在逗号分隔的分配中使用相应的表达式。
func (TypeAndValue) IsBuiltin
func (tv TypeAndValue) IsBuiltin() bool
IsBuiltin报告相应的表达式是否表示一个（可能带有括号的）内置函数。
func (TypeAndValue) IsNil
func (tv TypeAndValue) IsNil() bool
IsNil报告相应的表达式是否表示预声明的值nil。
func (TypeAndValue) IsType
func (tv TypeAndValue) IsType() bool
IsType报告相应的表达式是否指定类型。
func (TypeAndValue) IsValue
func (tv TypeAndValue) IsValue() bool
IsValue报告相应的表达式是否为值。 内置不被视为值。 常数值为非零值。
func (TypeAndValue) IsVoid
func (tv TypeAndValue) IsVoid() bool
IsVoid报告相应的表达式是否为没有结果的函数调用。
type TypeName
type TypeName struct {
// contains filtered or unexported fields
}
TypeName代表声明的类型。
func NewTypeName
func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName
func (*TypeName) Exported
func (obj *TypeName) Exported() bool
func (*TypeName) Id
func (obj *TypeName) Id() string
func (*TypeName) Name
func (obj *TypeName) Name() string
func (*TypeName) Parent
func (obj *TypeName) Parent() *Scope
func (*TypeName) Pkg
func (obj *TypeName) Pkg() *Package
func (*TypeName) Pos
func (obj *TypeName) Pos() token.Pos
func (*TypeName) String
func (obj *TypeName) String() string
func (*TypeName) Type
func (obj *TypeName) Type() Type
type Var
type Var struct {
// contains filtered or unexported fields
}
变量表示已声明的变量（包括函数参数和结果以及结构字段）。
func NewField
func NewField(pos token.Pos, pkg *Package, name string, typ Type, anonymous bool) *Var
func NewParam
func NewParam(pos token.Pos, pkg *Package, name string, typ Type) *Var
func NewVar
func NewVar(pos token.Pos, pkg *Package, name string, typ Type) *Var
func (*Var) Anonymous
func (obj *Var) Anonymous() bool
func (*Var) Exported
func (obj *Var) Exported() bool
func (*Var) Id
func (obj *Var) Id() string
func (*Var) IsField
func (obj *Var) IsField() bool
func (*Var) Name
func (obj *Var) Name() string
func (*Var) Parent
func (obj *Var) Parent() *Scope
func (*Var) Pkg
func (obj *Var) Pkg() *Package
func (*Var) Pos
func (obj *Var) Pos() token.Pos
func (*Var) String
func (obj *Var) String() string
func (*Var) Type
func (obj *Var) Type() Type
有疑问加站长微信联系（非本文作者）
