Golang标准库——go(4)

• 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

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

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

func (*Interface) Method

func (t *Interface) Method(i int) *Func

方法为0 <= i

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

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

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

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

func (*Struct) String

func (t *Struct) String() string

func (*Struct) Tag

func (s *Struct) Tag(i int) string

Tag返回第i个字段标签，其值为0 <= i

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