Package types

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(V *Interface, T Type) bool

func AssignableTo(V, T Type) bool

func Comparable(T Type) bool

func ConvertibleTo(V, T Type) bool

func DefPredeclaredTestFuncs()

func ExprString(x ast.Expr) string

func Id(pkg *Package, name string) string

func Identical(x, y Type) bool

func IdenticalIgnoreTags(x, y Type) bool

func Implements(V Type, T *Interface) bool

func IsInterface(typ Type) bool

func ObjectString(obj Object, qf Qualifier) string

func SelectionString(s *Selection, qf Qualifier) string

"field (T) f int"
"method (T) f(X) Y"
"method expr (T) f(X) Y"

func TypeString(typ Type, qf Qualifier) string

func WriteExpr(buf *bytes.Buffer, x ast.Expr)

func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier)

func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier)

type Array struct {
        // contains filtered or unexported fields
}

func NewArray(elem Type, len int64) *Array

func (a *Array) Elem() Type

func (a *Array) Len() int64

func (t *Array) String() string

func (t *Array) Underlying() Type

type Basic struct {
        // contains filtered or unexported fields
}

func (b *Basic) Info() BasicInfo

func (b *Basic) Kind() BasicKind

func (b *Basic) Name() string

func (t *Basic) String() string

func (t *Basic) Underlying() Type

type BasicInfo int

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 int

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 struct {
        // contains filtered or unexported fields
}

func (obj *Builtin) Exported() bool

func (obj *Builtin) Id() string

func (obj *Builtin) Name() string

func (obj *Builtin) Parent() *Scope

func (obj *Builtin) Pkg() *Package

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

func (obj *Builtin) String() string

func (obj *Builtin) Type() Type

type Chan struct {
        // contains filtered or unexported fields
}

func NewChan(dir ChanDir, elem Type) *Chan

func (c *Chan) Dir() ChanDir

func (c *Chan) Elem() Type

func (t *Chan) String() string

func (t *Chan) Underlying() Type

type ChanDir int

const (
        SendRecv ChanDir = iota
        SendOnly
        RecvOnly
)

type Checker struct {
        *Info
        // contains filtered or unexported fields
}

func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Checker

func (check *Checker) Files(files []*ast.File) error

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-on 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 SizesFor("gc", "amd64") is used instead.
        Sizes Sizes

        // If DisableUnusedImportCheck is set, packages are not checked
        // for unused imports.
        DisableUnusedImportCheck bool
}

func (conf *Config) Check(path string, fset *token.FileSet, files []*ast.File, info *Info) (*Package, error)

type Const struct {
        // contains filtered or unexported fields
}

func NewConst(pos token.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const

func (obj *Const) Exported() bool

func (obj *Const) Id() string

func (obj *Const) Name() string

func (obj *Const) Parent() *Scope

func (obj *Const) Pkg() *Package

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

func (obj *Const) String() string

func (obj *Const) Type() Type

func (obj *Const) Val() constant.Value

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 (err Error) Error() string

type Func struct {
        // contains filtered or unexported fields
}

func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool)

func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func

func (obj *Func) Exported() bool

func (obj *Func) FullName() string

func (obj *Func) Id() string

func (obj *Func) Name() string

func (obj *Func) Parent() *Scope

func (obj *Func) Pkg() *Package

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

func (obj *Func) Scope() *Scope

func (obj *Func) String() string

func (obj *Func) Type() Type

type ImportMode int

type Importer interface {
        // Import returns the imported package for the given import path.
        // The semantics is like for ImporterFrom.ImportFrom except that
        // dir and mode are ignored (since they are not present).
        Import(path string) (*Package, error)
}

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 a package file located in dir.
        // If the import failed, besides returning an error, ImportFrom
        // is encouraged to cache and return a package anyway, if one
        // was created. This will reduce package inconsistencies and
        // follow-on type checker errors due to the missing package.
        // The mode value must be 0; it is reserved for future use.
        // Two calls to ImportFrom with the same path and dir must
        // return the same package.
        ImportFrom(path, dir string, mode ImportMode) (*Package, error)
}

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
}

// Parse a single source file.
const input = `
package fib

type S string

var a, b, c = len(b), S(c), "hello"

func fib(x int) int {
        if x < 2 {
                return x
        }
        return fib(x-1) - fib(x-2)
}`
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "fib.go", input, 0)
if err != nil {
        log.Fatal(err)
}

// Type-check the package.
// We create an empty map for each kind of input
// we're interested in, and Check populates them.
info := types.Info{
        Types: make(map[ast.Expr]types.TypeAndValue),
        Defs:  make(map[*ast.Ident]types.Object),
        Uses:  make(map[*ast.Ident]types.Object),
}
var conf types.Config
pkg, err := conf.Check("fib", fset, []*ast.File{f}, &info)
if err != nil {
        log.Fatal(err)
}

// Print package-level variables in initialization order.
fmt.Printf("InitOrder: %v\n\n", info.InitOrder)

// For each named object, print the line and
// column of its definition and each of its uses.
fmt.Println("Defs and Uses of each named object:")
usesByObj := make(map[types.Object][]string)
for id, obj := range info.Uses {
        posn := fset.Position(id.Pos())
        lineCol := fmt.Sprintf("%d:%d", posn.Line, posn.Column)
        usesByObj[obj] = append(usesByObj[obj], lineCol)
}
var items []string
for obj, uses := range usesByObj {
        sort.Strings(uses)
        item := fmt.Sprintf("%s:\n  defined at %s\n  used at %s",
                types.ObjectString(obj, types.RelativeTo(pkg)),
                fset.Position(obj.Pos()),
                strings.Join(uses, ", "))
        items = append(items, item)
}
sort.Strings(items) // sort by line:col, in effect
fmt.Println(strings.Join(items, "\n"))
fmt.Println()

fmt.Println("Types and Values of each expression:")
items = nil
for expr, tv := range info.Types {
        var buf bytes.Buffer
        posn := fset.Position(expr.Pos())
        tvstr := tv.Type.String()
        if tv.Value != nil {
                tvstr += " = " + tv.Value.String()
        }
        // line:col | expr | mode : type = value
        fmt.Fprintf(&buf, "%2d:%2d | %-19s | %-7s : %s",
                posn.Line, posn.Column, exprString(fset, expr),
                mode(tv), tvstr)
        items = append(items, buf.String())
}
sort.Strings(items)
fmt.Println(strings.Join(items, "\n"))

InitOrder: [c = "hello" b = S(c) a = len(b)]

Defs and Uses of each named object:
builtin len:
  defined at -
  used at 6:15
func fib(x int) int:
  defined at fib.go:8:6
  used at 12:20, 12:9
type S string:
  defined at fib.go:4:6
  used at 6:23
type int:
  defined at -
  used at 8:12, 8:17
type string:
  defined at -
  used at 4:8
var b S:
  defined at fib.go:6:8
  used at 6:19
var c string:
  defined at fib.go:6:11
  used at 6:25
var x int:
  defined at fib.go:8:10
  used at 10:10, 12:13, 12:24, 9:5

Types and Values of each expression:
 4: 8 | string              | type    : string
 6:15 | len                 | builtin : func(string) int
 6:15 | len(b)              | value   : int
 6:19 | b                   | var     : fib.S
 6:23 | S                   | type    : fib.S
 6:23 | S(c)                | value   : fib.S
 6:25 | c                   | var     : string
 6:29 | "hello"             | value   : string = "hello"
 8:12 | int                 | type    : int
 8:17 | int                 | type    : int
 9: 5 | x                   | var     : int
 9: 5 | x < 2               | value   : untyped bool
 9: 9 | 2                   | value   : int = 2
10:10 | x                   | var     : int
12: 9 | fib                 | value   : func(x int) int
12: 9 | fib(x - 1)          | value   : int
12: 9 | fib(x-1) - fib(x-2) | value   : int
12:13 | x                   | var     : int
12:13 | x - 1               | value   : int
12:15 | 1                   | value   : int = 1
12:20 | fib                 | value   : func(x int) int
12:20 | fib(x - 2)          | value   : int
12:24 | x                   | var     : int
12:24 | x - 2               | value   : int
12:26 | 2                   | value   : int = 2

func (info *Info) ObjectOf(id *ast.Ident) Object

func (info *Info) TypeOf(e ast.Expr) Type

type Initializer struct {
        Lhs []*Var // var Lhs = Rhs
        Rhs ast.Expr
}

func (init *Initializer) String() string

type Interface struct {
        // contains filtered or unexported fields
}

func NewInterface(methods []*Func, embeddeds []*Named) *Interface

func (t *Interface) Complete() *Interface

func (t *Interface) Embedded(i int) *Named

func (t *Interface) Empty() bool

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

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

func (t *Interface) NumEmbeddeds() int

func (t *Interface) NumExplicitMethods() int

func (t *Interface) NumMethods() int

func (t *Interface) String() string

func (t *Interface) Underlying() Type

type Label struct {
        // contains filtered or unexported fields
}

func NewLabel(pos token.Pos, pkg *Package, name string) *Label

func (obj *Label) Exported() bool

func (obj *Label) Id() string

func (obj *Label) Name() string

func (obj *Label) Parent() *Scope

func (obj *Label) Pkg() *Package

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

func (obj *Label) String() string

func (obj *Label) Type() Type

type Map struct {
        // contains filtered or unexported fields
}

func NewMap(key, elem Type) *Map

func (m *Map) Elem() Type

func (m *Map) Key() Type

func (t *Map) String() string

func (t *Map) Underlying() Type

type MethodSet struct {
        // contains filtered or unexported fields
}

package main

import (
	"fmt"
	"go/ast"
	"go/importer"
	"go/parser"
	"go/token"
	"go/types"
	"log"
)

func main() {
	// Parse a single source file.
	const input = `
package temperature
import "fmt"
type Celsius float64
func (c Celsius) String() string  { return fmt.Sprintf("%g°C", c) }
func (c *Celsius) SetF(f float64) { *c = Celsius(f - 32 / 9 * 5) }
`
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "celsius.go", input, 0)
	if err != nil {
		log.Fatal(err)
	}

	// Type-check a package consisting of this file.
	// Type information for the imported packages
	// comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a.
	conf := types.Config{Importer: importer.Default()}
	pkg, err := conf.Check("temperature", fset, []*ast.File{f}, nil)
	if err != nil {
		log.Fatal(err)
	}

	// Print the method sets of Celsius and *Celsius.
	celsius := pkg.Scope().Lookup("Celsius").Type()
	for _, t := range []types.Type{celsius, types.NewPointer(celsius)} {
		fmt.Printf("Method set of %s:\n", t)
		mset := types.NewMethodSet(t)
		for i := 0; i < mset.Len( i++ {
			fmt.Println(mset.At(i))
		}
		fmt.Println()
	}

}

func NewMethodSet(T Type) *MethodSet

func (s *MethodSet) At(i int) *Selection

func (s *MethodSet) Len() int

func (s *MethodSet) Lookup(pkg *Package, name string) *Selection

func (s *MethodSet) String() string

type Named struct {
        // contains filtered or unexported fields
}

func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named

func (t *Named) AddMethod(m *Func)

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

func (t *Named) NumMethods() int

func (t *Named) Obj() *TypeName

func (t *Named) SetUnderlying(underlying Type)

func (t *Named) String() string

func (t *Named) Underlying() Type

type Nil struct {
        // contains filtered or unexported fields
}

func (obj *Nil) Exported() bool

func (obj *Nil) Id() string

func (obj *Nil) Name() string

func (obj *Nil) Parent() *Scope

func (obj *Nil) Pkg() *Package

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

func (obj *Nil) String() string

func (obj *Nil) Type() Type

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 name if exported, qualified name if not exported (see func Id)

        // String returns a human-readable string of the object.
        String() string
        // contains filtered or unexported methods
}

func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool)

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.

	- 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 struct {
        // contains filtered or unexported fields
}

func NewPackage(path, name string) *Package

func (pkg *Package) Complete() bool

func (pkg *Package) Imports() []*Package

func (pkg *Package) MarkComplete()

func (pkg *Package) Name() string

func (pkg *Package) Path() string

func (pkg *Package) Scope() *Scope

func (pkg *Package) SetImports(list []*Package)

func (pkg *Package) SetName(name string)

func (pkg *Package) String() string

type PkgName struct {
        // contains filtered or unexported fields
}

func NewPkgName(pos token.Pos, pkg *Package, name string, imported *Package) *PkgName

func (obj *PkgName) Exported() bool

func (obj *PkgName) Id() string

func (obj *PkgName) Imported() *Package

func (obj *PkgName) Name() string

func (obj *PkgName) Parent() *Scope

func (obj *PkgName) Pkg() *Package

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

func (obj *PkgName) String() string

func (obj *PkgName) Type() Type

type Pointer struct {
        // contains filtered or unexported fields
}

func NewPointer(elem Type) *Pointer

func (p *Pointer) Elem() Type

func (t *Pointer) String() string

func (t *Pointer) Underlying() Type

type Qualifier func(*Package) string

func RelativeTo(pkg *Package) Qualifier

type Scope struct {
        // contains filtered or unexported fields
}

package main

import (
	"bytes"
	"fmt"
	"go/ast"
	"go/importer"
	"go/parser"
	"go/token"
	"go/types"
	"log"
	"regexp"
)

func main() {
	// Parse the source files for a package.
	fset := token.NewFileSet()
	var files []*ast.File
	for _, file := range []struct{ name, input string }{
		{"main.go", `
package main
import "fmt"
func main() {
	freezing := FToC(-18)
	fmt.Println(freezing, Boiling) }
`},
		{"celsius.go", `
package main
import "fmt"
type Celsius float64
func (c Celsius) String() string { return fmt.Sprintf("%g°C", c) }
func FToC(f float64) Celsius { return Celsius(f - 32 / 9 * 5) }
const Boiling Celsius = 100
`},
	} {
		f, err := parser.ParseFile(fset, file.name, file.input, 0)
		if err != nil {
			log.Fatal(err)
		}
		files = append(files, f)
	}

	// Type-check a package consisting of these files.
	// Type information for the imported "fmt" package
	// comes from $GOROOT/pkg/$GOOS_$GOOARCH/fmt.a.
	conf := types.Config{Importer: importer.Default()}
	pkg, err := conf.Check("temperature", fset, files, nil)
	if err != nil {
		log.Fatal(err)
	}

	// Print the tree of scopes.
	// For determinism, we redact addresses.
	var buf bytes.Buffer
	pkg.Scope().WriteTo(&buf, 0, true)
	rx := regexp.MustCompile(` 0x[a-fA-F0-9]*`)
	fmt.Println(rx.ReplaceAllString(buf.String(), ""))

}

func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope

func (s *Scope) Child(i int) *Scope

func (s *Scope) Contains(pos token.Pos) bool

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

func (s *Scope) Innermost(pos token.Pos) *Scope

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

func (s *Scope) Len() int

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

func (s *Scope) LookupParent(name string, pos token.Pos) (*Scope, Object)

func (s *Scope) Names() []string

func (s *Scope) NumChildren() int

func (s *Scope) Parent() *Scope

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

func (s *Scope) String() string

func (s *Scope) WriteTo(w io.Writer, n int, recurse bool)

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

type Selection struct {
        // contains filtered or unexported fields
}

func (s *Selection) Index() []int

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.

func (s *Selection) Indirect() bool

func (s *Selection) Kind() SelectionKind

func (s *Selection) Obj() Object

func (s *Selection) Recv() Type

func (s *Selection) String() string

func (s *Selection) Type() Type

type SelectionKind int

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 struct {
        // contains filtered or unexported fields
}

func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature

func (s *Signature) Params() *Tuple

func (s *Signature) Recv() *Var

func (s *Signature) Results() *Tuple

func (t *Signature) String() string

func (t *Signature) Underlying() Type

func (s *Signature) Variadic() bool

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
}

func SizesFor(compiler, arch string) Sizes

type Slice struct {
        // contains filtered or unexported fields
}

func NewSlice(elem Type) *Slice

func (s *Slice) Elem() Type

func (t *Slice) String() string

func (t *Slice) Underlying() Type

	- 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.

type StdSizes struct {
        WordSize int64 // word size in bytes - must be >= 4 (32bits)
        MaxAlign int64 // maximum alignment in bytes - must be >= 1
}

func (s *StdSizes) Alignof(T Type) int64

func (s *StdSizes) Offsetsof(fields []*Var) []int64

func (s *StdSizes) Sizeof(T Type) int64

type Struct struct {
        // contains filtered or unexported fields
}

func NewStruct(fields []*Var, tags []string) *Struct

func (s *Struct) Field(i int) *Var

func (s *Struct) NumFields() int

func (t *Struct) String() string

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

func (t *Struct) Underlying() Type

type Tuple struct {
        // contains filtered or unexported fields
}

func NewTuple(x ...*Var) *Tuple

func (t *Tuple) At(i int) *Var

func (t *Tuple) Len() int

func (t *Tuple) String() string

func (t *Tuple) Underlying() Type

type Type interface {
        // Underlying returns the underlying type of a type.
        Underlying() Type

        // String returns a string representation of a type.
        String() string
}

func Default(typ Type) Type

type TypeAndValue struct {
        Type  Type
        Value constant.Value
        // contains filtered or unexported fields
}

func Eval(fset *token.FileSet, pkg *Package, pos token.Pos, expr string) (TypeAndValue, error)

func (tv TypeAndValue) Addressable() bool

func (tv TypeAndValue) Assignable() bool

func (tv TypeAndValue) HasOk() bool

func (tv TypeAndValue) IsBuiltin() bool

func (tv TypeAndValue) IsNil() bool

func (tv TypeAndValue) IsType() bool

func (tv TypeAndValue) IsValue() bool

func (tv TypeAndValue) IsVoid() bool

type TypeName struct {
        // contains filtered or unexported fields
}

func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName

func (obj *TypeName) Exported() bool

func (obj *TypeName) Id() string

func (obj *TypeName) IsAlias() bool

func (obj *TypeName) Name() string

func (obj *TypeName) Parent() *Scope

func (obj *TypeName) Pkg() *Package

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

func (obj *TypeName) String() string

func (obj *TypeName) Type() Type

type Var struct {
        // contains filtered or unexported fields
}

func NewField(pos token.Pos, pkg *Package, name string, typ Type, anonymous bool) *Var

func NewParam(pos token.Pos, pkg *Package, name string, typ Type) *Var

func NewVar(pos token.Pos, pkg *Package, name string, typ Type) *Var

func (obj *Var) Anonymous() bool

func (obj *Var) Exported() bool

func (obj *Var) Id() string

func (obj *Var) IsField() bool

func (obj *Var) Name() string

func (obj *Var) Parent() *Scope

func (obj *Var) Pkg() *Package

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

func (obj *Var) String() string

func (obj *Var) Type() Type