Typ contains the predeclared *Basic types indexed by their corresponding BasicKind.
The *Basic type for Typ[Byte] will have the name "uint8". Use Universe.Lookup("byte").Type() to obtain the specific alias basic type named "byte" (and analogous for "rune").
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
AssertableTo reports whether a value of type V can be asserted to have type T.
The behavior of AssertableTo is unspecified in three cases:
func AssignableTo(V, T Type) bool
AssignableTo reports whether a value of type V is assignable to a variable of type T.
The behavior of AssignableTo is unspecified if V or T is Typ[Invalid] or an uninstantiated generic type.
func Comparable(T Type) bool
Comparable reports whether values of type T are comparable.
func ConvertibleTo(V, T Type) bool
ConvertibleTo reports whether a value of type V is convertible to a value of type T.
The behavior of ConvertibleTo is unspecified if V or T is Typ[Invalid] or an uninstantiated generic type.
func DefPredeclaredTestFuncs()
DefPredeclaredTestFuncs defines the assert and trace built-ins. These built-ins are intended for debugging and testing of this package only.
func ExprString(x syntax.Node) string
ExprString returns a string representation of x.
func Id(pkg *Package, name string) string
Id returns name if it is exported, otherwise it returns the name qualified with the package path.
func Identical(x, y Type) bool
Identical reports whether x and y are identical types. Receivers of Signature types are ignored.
Predicates such as Identical, Implements, and Satisfies assume that both operands belong to a consistent collection of symbols (Object values). For example, two Named types can be identical only if their Named.Obj methods return the same TypeName symbol. A collection of symbols is consistent if, for each logical package whose path is P, the creation of those symbols involved at most one call to NewPackage(P, ...). To ensure consistency, use a single Importer for all loaded packages and their dependencies. For more information, see https://github.com/golang/go/issues/57497.
func IdenticalIgnoreTags(x, y Type) bool
IdenticalIgnoreTags reports whether x and y are identical types if tags are ignored. Receivers of Signature types are ignored.
func Implements(V Type, T *Interface) bool
Implements reports whether type V implements interface T.
The behavior of Implements is unspecified if V is Typ[Invalid] or an uninstantiated generic type.
func IsInterface(t Type) bool
IsInterface reports whether t is an interface type.
func IsSyncAtomicAlign64(T Type) bool
func ObjectString(obj Object, qf Qualifier) string
ObjectString returns the string form of obj. The Qualifier controls the printing of package-level objects, and may be nil.
func RangeKeyVal(typ Type) (Type, Type)
RangeKeyVal returns the key and value types for a range over typ. Exported for use by the compiler (does not exist in go/types).
func Satisfies(V Type, T *Interface) bool
Satisfies reports whether type V satisfies the constraint T.
The behavior of Satisfies is unspecified if V is Typ[Invalid] or an uninstantiated generic type.
func SelectionString(s *Selection, qf Qualifier) string
SelectionString returns the string form of s. The Qualifier controls the printing of package-level objects, and may be nil.
Examples:
"field (T) f int" "method (T) f(X) Y" "method expr (T) f(X) Y"
func TypeString(typ Type, qf Qualifier) string
TypeString returns the string representation of typ. The Qualifier controls the printing of package-level objects, and may be nil.
func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier)
WriteSignature writes the representation of the signature sig to buf, without a leading "func" keyword. The Qualifier controls the printing of package-level objects, and may be nil.
func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier)
WriteType writes the string representation of typ to buf. The Qualifier controls the printing of package-level objects, and may be nil.
An Alias represents an alias type. Whether or not Alias types are created is controlled by the gotypesalias setting with the GODEBUG environment variable. For gotypesalias=1, alias declarations produce an Alias type. Otherwise, the alias information is only in the type name, which points directly to the actual (aliased) type.
type Alias struct {
// contains filtered or unexported fields
}
func NewAlias(obj *TypeName, rhs Type) *Alias
NewAlias creates a new Alias type with the given type name and rhs. rhs must not be nil.
func (a *Alias) Obj() *TypeName
Obj returns the type name for the declaration defining the alias type a. For instantiated types, this is same as the type name of the origin type.
func (a *Alias) Origin() *Alias
Origin returns the generic Alias type of which a is an instance. If a is not an instance of a generic alias, Origin returns a.
func (a *Alias) Rhs() Type
Rhs returns the type R on the right-hand side of an alias declaration "type A = R", which may be another alias.
func (a *Alias) SetTypeParams(tparams []*TypeParam)
SetTypeParams sets the type parameters of the alias type a. The alias a must not have type arguments.
func (a *Alias) String() string
func (a *Alias) TypeArgs() *TypeList
TypeArgs returns the type arguments used to instantiate the Alias type. If a is not an instance of a generic alias, the result is nil.
func (a *Alias) TypeParams() *TypeParamList
TypeParams returns the type parameters of the alias type a, or nil. A generic Alias and its instances have the same type parameters.
func (a *Alias) Underlying() Type
Underlying returns the underlying type of the alias type a, which is the underlying type of the aliased type. Underlying types are never Named, TypeParam, or Alias types.
An ArgumentError holds an error associated with an argument index.
type ArgumentError struct {
Index int
Err error
}
func (e *ArgumentError) Error() string
func (e *ArgumentError) Unwrap() error
An Array represents an array type.
type Array struct {
// contains filtered or unexported fields
}
func NewArray(elem Type, len int64) *Array
NewArray returns a new array type for the given element type and length. A negative length indicates an unknown length.
func (a *Array) Elem() Type
Elem returns element type of array a.
func (a *Array) Len() int64
Len returns the length of array a. A negative result indicates an unknown length.
func (a *Array) String() string
func (a *Array) Underlying() Type
A Basic represents a basic type.
type Basic struct {
// contains filtered or unexported fields
}
func (b *Basic) Info() BasicInfo
Info returns information about properties of basic type b.
func (b *Basic) Kind() BasicKind
Kind returns the kind of basic type b.
func (b *Basic) Name() string
Name returns the name of basic type b.
func (b *Basic) String() string
func (b *Basic) Underlying() Type
BasicInfo is a set of flags describing properties of a basic type.
type BasicInfo int
Properties of basic types.
const (
IsBoolean BasicInfo = 1 << iota
IsInteger
IsUnsigned
IsFloat
IsComplex
IsString
IsUntyped
IsOrdered = IsInteger | IsFloat | IsString
IsNumeric = IsInteger | IsFloat | IsComplex
IsConstType = IsBoolean | IsNumeric | IsString
)
BasicKind describes the kind of basic type.
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
)
A Builtin represents a built-in function. Builtins don't have a valid type.
type Builtin struct {
// contains filtered or unexported fields
}
func (obj *Builtin) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *Builtin) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *Builtin) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *Builtin) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *Builtin) Pkg() *Package
Pkg returns the package to which the object belongs. The result is nil for labels and objects in the Universe scope.
func (obj *Builtin) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *Builtin) String() string
func (obj *Builtin) Type() Type
Type returns the object's type.
A Chan represents a channel type.
type Chan struct {
// contains filtered or unexported fields
}
func NewChan(dir ChanDir, elem Type) *Chan
NewChan returns a new channel type for the given direction and element type.
func (c *Chan) Dir() ChanDir
Dir returns the direction of channel c.
func (c *Chan) Elem() Type
Elem returns the element type of channel c.
func (c *Chan) String() string
func (c *Chan) Underlying() Type
A ChanDir value indicates a channel direction.
type ChanDir int
The direction of a channel is indicated by one of these constants.
const (
SendRecv ChanDir = iota
SendOnly
RecvOnly
)
A Checker maintains the state of the type checker. It must be created with NewChecker.
type Checker struct {
*Info
// contains filtered or unexported fields
}
func NewChecker(conf *Config, pkg *Package, info *Info) *Checker
NewChecker returns a new Checker instance for a given package. Package files may be added incrementally via checker.Files.
func (check *Checker) Files(files []*syntax.File) (err error)
Files checks the provided files as part of the checker's package.
A Config specifies the configuration for type checking. The zero value for Config is a ready-to-use default configuration.
type Config struct {
// Context is the context used for resolving global identifiers. If nil, the
// type checker will initialize this field with a newly created context.
Context *Context
// GoVersion describes the accepted Go language version. The string must
// start with a prefix of the form "go%d.%d" (e.g. "go1.20", "go1.21rc1", or
// "go1.21.0") or it must be empty; an empty string disables Go language
// version checks. If the format is invalid, invoking the type checker will
// result in an error.
GoVersion string
// 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 IgnoreBranchErrors is set, branch/label errors are ignored.
IgnoreBranchErrors bool
// If Trace is set, a debug trace is printed to stdout.
Trace 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
// If a non-empty ErrorURL format string is provided, it is used
// to format an error URL link that is appended to the first line
// of an error message. ErrorURL must be a format string containing
// exactly one "%s" format, e.g. "[go.dev/e/%s]".
ErrorURL string
// If EnableAlias is set, alias declarations produce an Alias type. Otherwise
// the alias information is only in the type name, which points directly to
// the actual (aliased) type.
//
// This setting must not differ among concurrent type-checking operations,
// since it affects the behavior of Universe.Lookup("any").
//
// This flag will eventually be removed (with Go 1.24 at the earliest).
EnableAlias bool
// contains filtered or unexported fields
}
func (conf *Config) Check(path string, files []*syntax.File, info *Info) (*Package, error)
Check type-checks a package and returns the resulting package object and the first error if any. Additionally, if info != nil, Check populates each of the non-nil maps in the Info struct.
The package is marked as complete if no errors occurred, otherwise it is incomplete. See Config.Error for controlling behavior in the presence of errors.
The package is specified by a list of *syntax.Files and corresponding file set, and the package path the package is identified with. The clean path must not be empty or dot (".").
A Const represents a declared constant.
type Const struct {
// contains filtered or unexported fields
}
func NewConst(pos syntax.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const
NewConst returns a new constant with value val. The remaining arguments set the attributes found with all Objects.
func (obj *Const) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *Const) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *Const) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *Const) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *Const) Pkg() *Package
Pkg returns the package to which the object belongs. The result is nil for labels and objects in the Universe scope.
func (obj *Const) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *Const) String() string
func (obj *Const) Type() Type
Type returns the object's type.
func (obj *Const) Val() constant.Value
Val returns the constant's value.
A Context is an opaque type checking context. It may be used to share identical type instances across type-checked packages or calls to Instantiate. Contexts are safe for concurrent use.
The use of a shared context does not guarantee that identical instances are deduplicated in all cases.
type Context struct {
// contains filtered or unexported fields
}
func NewContext() *Context
NewContext creates a new Context.
An Error describes a type-checking error; it implements the error interface. A "soft" error is an error that still permits a valid interpretation of a package (such as "unused variable"); "hard" errors may lead to unpredictable behavior if ignored.
type Error struct {
Pos syntax.Pos // error position
Msg string // default error message, user-friendly
Full string // full error message, for debugging (may contain internal details)
Soft bool // if set, error is "soft"
Code Code // error code
}
func (err Error) Error() string
Error returns an error string formatted as follows: filename:line:column: message
func (err Error) FullError() string
FullError returns an error string like Error, buy it may contain type-checker internal details such as subscript indices for type parameters and more. Useful for debugging.
A Func represents a declared function, concrete method, or abstract (interface) method. Its Type() is always a *Signature. An abstract method may belong to many interfaces due to embedding.
type Func struct {
// contains filtered or unexported fields
}
func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool)
MissingMethod returns (nil, false) if V implements T, otherwise it returns a missing method required by T and whether it is missing or just has the wrong type: either a pointer receiver or wrong signature.
For non-interface types V, or if static is set, V implements T if all methods of T are present in V. Otherwise (V is an interface and static is not set), MissingMethod only checks that methods of T which are also present in V have matching types (e.g., for a type assertion x.(T) where x is of interface type V).
func NewFunc(pos syntax.Pos, pkg *Package, name string, sig *Signature) *Func
NewFunc returns a new function with the given signature, representing the function's type.
func (obj *Func) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *Func) FullName() string
FullName returns the package- or receiver-type-qualified name of function or method obj.
func (obj *Func) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *Func) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *Func) Origin() *Func
Origin returns the canonical Func for its receiver, i.e. the Func object recorded in Info.Defs.
For synthetic functions created during instantiation (such as methods on an instantiated Named type or interface methods that depend on type arguments), this will be the corresponding Func on the generic (uninstantiated) type. For all other Funcs Origin returns the receiver.
func (obj *Func) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *Func) Pkg() *Package
Pkg returns the package to which the function belongs.
The result is nil for methods of types in the Universe scope, like method Error of the error built-in interface type.
func (obj *Func) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *Func) Scope() *Scope
Scope returns the scope of the function's body block. The result is nil for imported or instantiated functions and methods (but there is also no mechanism to get to an instantiated function).
func (obj *Func) Signature() *Signature
Signature returns the signature (type) of the function or method.
func (obj *Func) String() string
func (obj *Func) Type() Type
Type returns the object's type.
ImportMode is reserved for future use.
type ImportMode int
An Importer resolves import paths to Packages.
CAUTION: This interface does not support the import of locally vendored packages. See https://golang.org/s/go15vendor. If possible, external implementations should implement ImporterFrom.
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)
}
An ImporterFrom resolves import paths to packages; it supports vendoring per https://golang.org/s/go15vendor. Use go/importer to obtain an ImporterFrom implementation.
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)
}
Info holds result type information for a type-checked package. Only the information for which a map is provided is collected. If the package has type errors, the collected information may be incomplete.
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[syntax.Expr]TypeAndValue
// If StoreTypesInSyntax is set, type information identical to
// that which would be put in the Types map, will be set in
// syntax.Expr.TypeAndValue (independently of whether Types
// is nil or not).
StoreTypesInSyntax bool
// Instances maps identifiers denoting generic types or functions to their
// type arguments and instantiated type.
//
// For example, Instances will map the identifier for 'T' in the type
// instantiation T[int, string] to the type arguments [int, string] and
// resulting instantiated *Named type. Given a generic function
// func F[A any](A), Instances will map the identifier for 'F' in the call
// expression F(int(1)) to the inferred type arguments [int], and resulting
// instantiated *Signature.
//
// Invariant: Instantiating Uses[id].Type() with Instances[id].TypeArgs
// results in an equivalent of Instances[id].Type.
Instances map[*syntax.Name]Instance
// 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 embedded field, Defs returns the field *Var it defines.
//
// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
Defs map[*syntax.Name]Object
// Uses maps identifiers to the objects they denote.
//
// For an embedded field, Uses returns the *TypeName it denotes.
//
// Invariant: Uses[id].Pos() != id.Pos()
Uses map[*syntax.Name]Object
// Implicits maps nodes to their implicitly declared objects, if any.
// The following node and object types may appear:
//
// node declared object
//
// *syntax.ImportDecl *PkgName for imports without renames
// *syntax.CaseClause type-specific *Var for each type switch case clause (incl. default)
// *syntax.Field anonymous parameter *Var (incl. unnamed results)
//
Implicits map[syntax.Node]Object
// Selections maps selector expressions (excluding qualified identifiers)
// to their corresponding selections.
Selections map[*syntax.SelectorExpr]*Selection
// Scopes maps syntax.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 Scope of a function contains the declarations of any
// type parameters, parameters, and named results, plus any
// local declarations in the body block.
// It is coextensive with the complete extent of the
// function's syntax ([*ast.FuncDecl] or [*ast.FuncLit]).
// The Scopes mapping does not contain an entry for the
// function body ([*ast.BlockStmt]); the function's scope is
// associated with the [*ast.FuncType].
//
// The following node types may appear in Scopes:
//
// *syntax.File
// *syntax.FuncType
// *syntax.TypeDecl
// *syntax.BlockStmt
// *syntax.IfStmt
// *syntax.SwitchStmt
// *syntax.CaseClause
// *syntax.CommClause
// *syntax.ForStmt
//
Scopes map[syntax.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
// FileVersions maps a file to its Go version string.
// If the file doesn't specify a version, the reported
// string is Config.GoVersion.
// Version strings begin with “go”, like “go1.21”, and
// are suitable for use with the [go/version] package.
FileVersions map[*syntax.PosBase]string
}
▹ Example
func (info *Info) ObjectOf(id *syntax.Name) Object
ObjectOf returns the object denoted by the specified id, or nil if not found.
If id is an embedded struct field, ObjectOf returns the field (*Var) it defines, not the type (*TypeName) it uses.
Precondition: the Uses and Defs maps are populated.
func (info *Info) PkgNameOf(imp *syntax.ImportDecl) *PkgName
PkgNameOf returns the local package name defined by the import, or nil if not found.
For dot-imports, the package name is ".".
Precondition: the Defs and Implicts maps are populated.
func (info *Info) TypeOf(e syntax.Expr) Type
TypeOf returns the type of expression e, or nil if not found. Precondition 1: the Types map is populated or StoreTypesInSyntax is set. Precondition 2: Uses and Defs maps are populated.
An Initializer describes a package-level variable, or a list of variables in case of a multi-valued initialization expression, and the corresponding initialization expression.
type Initializer struct {
Lhs []*Var // var Lhs = Rhs
Rhs syntax.Expr
}
func (init *Initializer) String() string
Instance reports the type arguments and instantiated type for type and function instantiations. For type instantiations, Type will be of dynamic type *Named. For function instantiations, Type will be of dynamic type *Signature.
type Instance struct {
TypeArgs *TypeList
Type Type
}
An Interface represents an interface type.
type Interface struct {
// contains filtered or unexported fields
}
func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface
NewInterfaceType returns a new interface for the given methods and embedded types. NewInterfaceType takes ownership of the provided methods and may modify their types by setting missing receivers.
func (t *Interface) EmbeddedType(i int) Type
EmbeddedType returns the i'th embedded type of interface t for 0 <= i < t.NumEmbeddeds().
func (t *Interface) Empty() bool
Empty reports whether t is the empty interface.
func (t *Interface) ExplicitMethod(i int) *Func
ExplicitMethod returns the i'th explicitly declared method of interface t for 0 <= i < t.NumExplicitMethods(). The methods are ordered by their unique Id.
func (t *Interface) IsComparable() bool
IsComparable reports whether each type in interface t's type set is comparable.
func (t *Interface) IsImplicit() bool
IsImplicit reports whether the interface t is a wrapper for a type set literal.
func (t *Interface) IsMethodSet() bool
IsMethodSet reports whether the interface t is fully described by its method set.
func (t *Interface) MarkImplicit()
MarkImplicit marks the interface t as implicit, meaning this interface corresponds to a constraint literal such as ~T or A|B without explicit interface embedding. MarkImplicit should be called before any concurrent use of implicit interfaces.
func (t *Interface) Method(i int) *Func
Method returns the i'th method of interface t for 0 <= i < t.NumMethods(). The methods are ordered by their unique Id.
func (t *Interface) NumEmbeddeds() int
NumEmbeddeds returns the number of embedded types in interface t.
func (t *Interface) NumExplicitMethods() int
NumExplicitMethods returns the number of explicitly declared methods of interface t.
func (t *Interface) NumMethods() int
NumMethods returns the total number of methods of interface t.
func (t *Interface) String() string
func (t *Interface) Underlying() Type
A Label represents a declared label. Labels don't have a type.
type Label struct {
// contains filtered or unexported fields
}
func NewLabel(pos syntax.Pos, pkg *Package, name string) *Label
NewLabel returns a new label.
func (obj *Label) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *Label) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *Label) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *Label) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *Label) Pkg() *Package
Pkg returns the package to which the object belongs. The result is nil for labels and objects in the Universe scope.
func (obj *Label) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *Label) String() string
func (obj *Label) Type() Type
Type returns the object's type.
A Map represents a map type.
type Map struct {
// contains filtered or unexported fields
}
func NewMap(key, elem Type) *Map
NewMap returns a new map for the given key and element types.
func (m *Map) Elem() Type
Elem returns the element type of map m.
func (m *Map) Key() Type
Key returns the key type of map m.
func (t *Map) String() string
func (t *Map) Underlying() Type
A Named represents a named (defined) type.
type Named struct {
// contains filtered or unexported fields
}
func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named
NewNamed returns a new named type for the given type name, underlying type, and associated methods. If the given type name obj doesn't have a type yet, its type is set to the returned named type. The underlying type must not be a *Named.
func (t *Named) AddMethod(m *Func)
AddMethod adds method m unless it is already in the method list. The method must be in the same package as t, and t must not have type arguments.
func (t *Named) Method(i int) *Func
Method returns the i'th method of named type t for 0 <= i < t.NumMethods().
For an ordinary or instantiated type t, the receiver base type of this method is the named type t. For an uninstantiated generic type t, each method receiver is instantiated with its receiver type parameters.
Methods are numbered deterministically: given the same list of source files presented to the type checker, or the same sequence of NewMethod and AddMethod calls, the mapping from method index to corresponding method remains the same. But the specific ordering is not specified and must not be relied on as it may change in the future.
func (t *Named) NumMethods() int
NumMethods returns the number of explicit methods defined for t.
func (t *Named) Obj() *TypeName
Obj returns the type name for the declaration defining the named type t. For instantiated types, this is same as the type name of the origin type.
func (t *Named) Origin() *Named
Origin returns the generic type from which the named type t is instantiated. If t is not an instantiated type, the result is t.
func (t *Named) SetTypeParams(tparams []*TypeParam)
SetTypeParams sets the type parameters of the named type t. t must not have type arguments.
func (t *Named) SetUnderlying(underlying Type)
SetUnderlying sets the underlying type and marks t as complete. t must not have type arguments.
func (t *Named) String() string
func (t *Named) TypeArgs() *TypeList
TypeArgs returns the type arguments used to instantiate the named type t.
func (t *Named) TypeParams() *TypeParamList
TypeParams returns the type parameters of the named type t, or nil. The result is non-nil for an (originally) generic type even if it is instantiated.
func (t *Named) Underlying() Type
Underlying returns the underlying type of the named type t, resolving all forwarding declarations. Underlying types are never Named, TypeParam, or Alias types.
Nil represents the predeclared value nil.
type Nil struct {
// contains filtered or unexported fields
}
func (obj *Nil) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *Nil) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *Nil) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *Nil) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *Nil) Pkg() *Package
Pkg returns the package to which the object belongs. The result is nil for labels and objects in the Universe scope.
func (obj *Nil) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *Nil) String() string
func (obj *Nil) Type() Type
Type returns the object's type.
An Object describes a named language entity such as a package, constant, type, variable, function (incl. methods), or label. All objects implement the Object interface.
type Object interface {
Parent() *Scope // scope in which this object is declared; nil for methods and struct fields
Pos() syntax.Pos // position of object identifier in declaration
Pkg() *Package // package to which this object belongs; nil for labels and objects in the Universe scope
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)
LookupFieldOrMethod looks up a field or method with given package and name in T and returns the corresponding *Var or *Func, an index sequence, and a bool indicating if there were any pointer indirections on the path to the field or method. If addressable is set, T is the type of an addressable variable (only matters for method lookups). T must not be nil.
The last index entry is the field or method index in the (possibly embedded) type where the entry was found, either:
The earlier index entries are the indices of the embedded struct fields traversed to get to the found entry, starting at depth 0.
If no entry is found, a nil object is returned. In this case, the returned index and indirect values have the following meaning:
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.
A Package describes a Go package.
type Package struct {
// contains filtered or unexported fields
}
The Unsafe package is the package returned by an importer for the import path "unsafe".
var Unsafe *Package
func NewPackage(path, name string) *Package
NewPackage returns a new Package for the given package path and name. The package is not complete and contains no explicit imports.
func (pkg *Package) Complete() bool
A package is complete if its scope contains (at least) all exported objects; otherwise it is incomplete.
func (pkg *Package) GoVersion() string
GoVersion returns the minimum Go version required by this package. If the minimum version is unknown, GoVersion returns the empty string. Individual source files may specify a different minimum Go version, as reported in the go/ast.File.GoVersion field.
func (pkg *Package) Imports() []*Package
Imports returns the list of packages directly imported by pkg; the list is in source order.
If pkg was loaded from export data, Imports includes packages that provide package-level objects referenced by pkg. This may be more or less than the set of packages directly imported by pkg's source code.
If pkg uses cgo and the FakeImportC configuration option was enabled, the imports list may contain a fake "C" package.
func (pkg *Package) MarkComplete()
MarkComplete marks a package as complete.
func (pkg *Package) Name() string
Name returns the package name.
func (pkg *Package) Path() string
Path returns the package path.
func (pkg *Package) Scope() *Scope
Scope returns the (complete or incomplete) package scope holding the objects declared at package level (TypeNames, Consts, Vars, and Funcs). For a nil pkg receiver, Scope returns the Universe scope.
func (pkg *Package) SetImports(list []*Package)
SetImports sets the list of explicitly imported packages to list. It is the caller's responsibility to make sure list elements are unique.
func (pkg *Package) SetName(name string)
SetName sets the package name.
func (pkg *Package) String() string
A PkgName represents an imported Go package. PkgNames don't have a type.
type PkgName struct {
// contains filtered or unexported fields
}
func NewPkgName(pos syntax.Pos, pkg *Package, name string, imported *Package) *PkgName
NewPkgName returns a new PkgName object representing an imported package. The remaining arguments set the attributes found with all Objects.
func (obj *PkgName) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *PkgName) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *PkgName) Imported() *Package
Imported returns the package that was imported. It is distinct from Pkg(), which is the package containing the import statement.
func (obj *PkgName) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *PkgName) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *PkgName) Pkg() *Package
Pkg returns the package to which the object belongs. The result is nil for labels and objects in the Universe scope.
func (obj *PkgName) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *PkgName) String() string
func (obj *PkgName) Type() Type
Type returns the object's type.
A Pointer represents a pointer type.
type Pointer struct {
// contains filtered or unexported fields
}
func AsPointer(t Type) *Pointer
If t is a pointer, AsPointer returns that type, otherwise it returns nil.
func NewPointer(elem Type) *Pointer
NewPointer returns a new pointer type for the given element (base) type.
func (p *Pointer) Elem() Type
Elem returns the element type for the given pointer p.
func (p *Pointer) String() string
func (p *Pointer) Underlying() Type
A Qualifier controls how named package-level objects are printed in calls to TypeString, ObjectString, and SelectionString.
These three formatting routines call the Qualifier for each package-level object O, and if the Qualifier returns a non-empty string p, the object is printed in the form p.O. If it returns an empty string, only the object name O is printed.
Using a nil Qualifier is equivalent to using (*Package).Path: the object is qualified by the import path, e.g., "encoding/json.Marshal".
type Qualifier func(*Package) string
func RelativeTo(pkg *Package) Qualifier
RelativeTo returns a Qualifier that fully qualifies members of all packages other than pkg.
A Scope maintains a set of objects and links to its containing (parent) and contained (children) scopes. Objects may be inserted and looked up by name. The zero value for Scope is a ready-to-use empty scope.
type Scope struct {
// contains filtered or unexported fields
}
The Universe scope contains all predeclared objects of Go. It is the outermost scope of any chain of nested scopes.
var Universe *Scope
▹ Example
func NewScope(parent *Scope, pos, end syntax.Pos, comment string) *Scope
NewScope returns a new, empty scope contained in the given parent scope, if any. The comment is for debugging only.
func (s *Scope) Child(i int) *Scope
Child returns the i'th child scope for 0 <= i < NumChildren().
func (s *Scope) Contains(pos syntax.Pos) bool
Contains reports whether pos is within the scope's extent. The result is guaranteed to be valid only if the type-checked AST has complete position information.
func (s *Scope) End() syntax.Pos
func (s *Scope) Innermost(pos syntax.Pos) *Scope
Innermost returns the innermost (child) scope containing pos. If pos is not within any scope, the result is nil. The result is also nil for the Universe scope. The result is guaranteed to be valid only if the type-checked AST has complete position information.
func (s *Scope) Insert(obj Object) Object
Insert attempts to insert an object obj into scope s. If s already contains an alternative object alt with the same name, Insert leaves s unchanged and returns alt. Otherwise it inserts obj, sets the object's parent scope if not already set, and returns nil.
func (s *Scope) InsertLazy(name string, resolve func() Object) bool
InsertLazy is like Insert, but allows deferring construction of the inserted object until it's accessed with Lookup. The Object returned by resolve must have the same name as given to InsertLazy. If s already contains an alternative object with the same name, InsertLazy leaves s unchanged and returns false. Otherwise it records the binding and returns true. The object's parent scope will be set to s after resolve is called.
func (s *Scope) Len() int
Len returns the number of scope elements.
func (s *Scope) Lookup(name string) Object
Lookup returns the object in scope s with the given name if such an object exists; otherwise the result is nil.
func (s *Scope) LookupParent(name string, pos syntax.Pos) (*Scope, Object)
LookupParent follows the parent chain of scopes starting with s until it finds a scope where Lookup(name) returns a non-nil object, and then returns that scope and object. If a valid position pos is provided, only objects that were declared at or before pos are considered. If no such scope and object exists, the result is (nil, nil).
Note that obj.Parent() may be different from the returned scope if the object was inserted into the scope and already had a parent at that time (see Insert). This can only happen for dot-imported objects whose scope is the scope of the package that exported them.
func (s *Scope) Names() []string
Names returns the scope's element names in sorted order.
func (s *Scope) NumChildren() int
NumChildren returns the number of scopes nested in s.
func (s *Scope) Parent() *Scope
Parent returns the scope's containing (parent) scope.
func (s *Scope) Pos() syntax.Pos
Pos and End describe the scope's source code extent [pos, end). The results are guaranteed to be valid only if the type-checked AST has complete position information. The extent is undefined for Universe and package scopes.
func (s *Scope) Squash(err func(obj, alt Object))
Squash merges s with its parent scope p by adding all objects of s to p, adding all children of s to the children of p, and removing s from p's children. The function f is called for each object obj in s which has an object alt in p. s should be discarded after having been squashed.
func (s *Scope) String() string
String returns a string representation of the scope, for debugging.
func (s *Scope) WriteTo(w io.Writer, n int, recurse bool)
WriteTo writes a string representation of the scope to w, with the scope elements sorted by name. The level of indentation is controlled by n >= 0, with n == 0 for no indentation. If recurse is set, it also writes nested (children) scopes.
A Selection describes a selector expression x.f. For the declarations:
type T struct{ x int; E }
type E struct{}
func (e E) m() {}
var p *T
the following relations exist:
Selector Kind Recv Obj Type Index Indirect
p.x FieldVal T x int {0} true
p.m MethodVal *T m func() {1, 0} true
T.m MethodExpr T m func(T) {1, 0} false
type Selection struct {
// contains filtered or unexported fields
}
func (s *Selection) Index() []int
Index describes the path from x to f in x.f. The last index entry is the field or method index of the type declaring f; either:
The earlier index entries are the indices of the embedded fields implicitly traversed to get from (the type of) x to f, starting at embedding depth 0.
func (s *Selection) Indirect() bool
Indirect reports whether any pointer indirection was required to get from x to f in x.f.
Beware: Indirect spuriously returns true (Go issue #8353) for a MethodVal selection in which the receiver argument and parameter both have type *T so there is no indirection. Unfortunately, a fix is too risky.
func (s *Selection) Kind() SelectionKind
Kind returns the selection kind.
func (s *Selection) Obj() Object
Obj returns the object denoted by x.f; a *Var for a field selection, and a *Func in all other cases.
func (s *Selection) Recv() Type
Recv returns the type of x in x.f.
func (s *Selection) String() string
func (s *Selection) Type() Type
Type returns the type of x.f, which may be different from the type of f. See Selection for more information.
SelectionKind describes the kind of a selector expression x.f (excluding qualified identifiers).
If x is a struct or *struct, a selector expression x.f may denote a sequence of selection operations x.a.b.c.f. The SelectionKind describes the kind of the final (explicit) operation; all the previous (implicit) operations are always field selections. Each element of Indices specifies an implicit field (a, b, c) by its index in the struct type of the field selection operand.
For a FieldVal operation, the final selection refers to the field specified by Selection.Obj.
For a MethodVal operation, the final selection refers to a method. If the "pointerness" of the method's declared receiver does not match that of the effective receiver after implicit field selection, then an & or * operation is implicitly applied to the receiver variable or value. So, x.f denotes (&x.a.b.c).f when f requires a pointer receiver but x.a.b.c is a non-pointer variable; and it denotes (*x.a.b.c).f when f requires a non-pointer receiver but x.a.b.c is a pointer value.
All pointer indirections, whether due to implicit or explicit field selections or * operations inserted for "pointerness", panic if applied to a nil pointer, so a method call x.f() may panic even before the function call.
By contrast, a MethodExpr operation T.f is essentially equivalent to a function literal of the form:
func(x T, args) (results) { return x.f(args) }
Consequently, any implicit field selections and * operations inserted for "pointerness" are not evaluated until the function is called, so a T.f or (*T).f expression never panics.
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
)
A Signature represents a (non-builtin) function or method type. The receiver is ignored when comparing signatures for identity.
type Signature struct {
// contains filtered or unexported fields
}
func AsSignature(t Type) *Signature
If t is a signature, AsSignature returns that type, otherwise it returns nil.
func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature
NewSignatureType creates a new function type for the given receiver, receiver type parameters, type parameters, parameters, and results. If variadic is set, params must hold at least one parameter and the last parameter's core type must be of unnamed slice or bytestring type. If recv is non-nil, typeParams must be empty. If recvTypeParams is non-empty, recv must be non-nil.
func (s *Signature) Params() *Tuple
Params returns the parameters of signature s, or nil.
func (s *Signature) Recv() *Var
Recv returns the receiver of signature s (if a method), or nil if a function. It is ignored when comparing signatures for identity.
For an abstract method, Recv returns the enclosing interface either as a *Named or an *Interface. Due to embedding, an interface may contain methods whose receiver type is a different interface.
func (s *Signature) RecvTypeParams() *TypeParamList
RecvTypeParams returns the receiver type parameters of signature s, or nil.
func (s *Signature) RenameResult(results []*syntax.Field, i int) (*Var, *syntax.Name)
RenameResult takes an array of (result) fields and an index, and if the indexed field does not have a name and if the result in the signature also does not have a name, then the signature and field are renamed to
fmt.Sprintf("#rv%d", i+1)`
the newly named object is inserted into the signature's scope, and the object and new field name are returned.
The intended use for RenameResult is to allow rangefunc to assign results within a closure. This is a hack, as narrowly targeted as possible to discourage abuse.
func (s *Signature) Results() *Tuple
Results returns the results of signature s, or nil.
func (s *Signature) String() string
func (s *Signature) TypeParams() *TypeParamList
TypeParams returns the type parameters of signature s, or nil.
func (s *Signature) Underlying() Type
func (s *Signature) Variadic() bool
Variadic reports whether the signature s is variadic.
Sizes defines the sizing functions for package unsafe.
type Sizes interface {
// Alignof returns the alignment of a variable of type T.
// Alignof must implement the alignment guarantees required by the spec.
// The result must be >= 1.
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.
// A negative entry in the result indicates that the struct is too large.
Offsetsof(fields []*Var) []int64
// Sizeof returns the size of a variable of type T.
// Sizeof must implement the size guarantees required by the spec.
// A negative result indicates that T is too large.
Sizeof(T Type) int64
}
func SizesFor(compiler, arch string) Sizes
SizesFor returns the Sizes used by a compiler for an architecture. The result is nil if a compiler/architecture pair is not known.
Supported architectures for compiler "gc": "386", "amd64", "amd64p32", "arm", "arm64", "loong64", "mips", "mipsle", "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x", "sparc64", "wasm".
A Slice represents a slice type.
type Slice struct {
// contains filtered or unexported fields
}
func NewSlice(elem Type) *Slice
NewSlice returns a new slice type for the given element type.
func (s *Slice) Elem() Type
Elem returns the element type of slice s.
func (s *Slice) String() string
func (s *Slice) Underlying() Type
StdSizes is a convenience type for creating commonly used Sizes. It makes the following simplifying assumptions:
*StdSizes implements Sizes.
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) (result int64)
func (s *StdSizes) Offsetsof(fields []*Var) []int64
func (s *StdSizes) Sizeof(T Type) int64
A Struct represents a struct type.
type Struct struct {
// contains filtered or unexported fields
}
func NewStruct(fields []*Var, tags []string) *Struct
NewStruct returns a new struct with the given fields and corresponding field tags. If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be only as long as required to hold the tag with the largest index i. Consequently, if no field has a tag, tags may be nil.
func (s *Struct) Field(i int) *Var
Field returns the i'th field for 0 <= i < NumFields().
func (s *Struct) NumFields() int
NumFields returns the number of fields in the struct (including blank and embedded fields).
func (s *Struct) String() string
func (s *Struct) Tag(i int) string
Tag returns the i'th field tag for 0 <= i < NumFields().
func (s *Struct) Underlying() Type
A Term represents a term in a Union.
type Term term
func NewTerm(tilde bool, typ Type) *Term
NewTerm returns a new union term.
func (t *Term) String() string
func (t *Term) Tilde() bool
func (t *Term) Type() Type
A Tuple represents an ordered list of variables; a nil *Tuple is a valid (empty) tuple. Tuples are used as components of signatures and to represent the type of multiple assignments; they are not first class types of Go.
type Tuple struct {
// contains filtered or unexported fields
}
func NewTuple(x ...*Var) *Tuple
NewTuple returns a new tuple for the given variables.
func (t *Tuple) At(i int) *Var
At returns the i'th variable of tuple t.
func (t *Tuple) Len() int
Len returns the number variables of tuple t.
func (t *Tuple) String() string
func (t *Tuple) Underlying() Type
A Type represents a type of Go. All types implement the Type interface.
type Type = syntax.Type
func CoreType(t Type) Type
If typ is a type parameter, CoreType returns the single underlying type of all types in the corresponding type constraint if it exists, or nil otherwise. If the type set contains only unrestricted and restricted channel types (with identical element types), the single underlying type is the restricted channel type if the restrictions are always the same. If typ is not a type parameter, CoreType returns the underlying type.
func Default(t Type) Type
Default returns the default "typed" type for an "untyped" type; it returns the incoming type for all other types. The default type for untyped nil is untyped nil.
func Instantiate(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error)
Instantiate instantiates the type orig with the given type arguments targs. orig must be an *Alias, *Named, or *Signature type. If there is no error, the resulting Type is an instantiated type of the same kind (*Alias, *Named or *Signature, respectively).
Methods attached to a *Named type are also instantiated, and associated with a new *Func that has the same position as the original method, but nil function scope.
If ctxt is non-nil, it may be used to de-duplicate the instance against previous instances with the same identity. As a special case, generic *Signature origin types are only considered identical if they are pointer equivalent, so that instantiating distinct (but possibly identical) signatures will yield different instances. The use of a shared context does not guarantee that identical instances are deduplicated in all cases.
If validate is set, Instantiate verifies that the number of type arguments and parameters match, and that the type arguments satisfy their respective type constraints. If verification fails, the resulting error may wrap an *ArgumentError indicating which type argument did not satisfy its type parameter constraint, and why.
If validate is not set, Instantiate does not verify the type argument count or whether the type arguments satisfy their constraints. Instantiate is guaranteed to not return an error, but may panic. Specifically, for *Signature types, Instantiate will panic immediately if the type argument count is incorrect; for *Named types, a panic may occur later inside the *Named API.
func Unalias(t Type) Type
Unalias returns t if it is not an alias type; otherwise it follows t's alias chain until it reaches a non-alias type which is then returned. Consequently, the result is never an alias type.
TypeAndValue reports the type and value (for constants) of the corresponding expression.
type TypeAndValue struct {
Type Type
Value constant.Value
// contains filtered or unexported fields
}
func (tv TypeAndValue) Addressable() bool
Addressable reports whether the corresponding expression is addressable (https://golang.org/ref/spec#Address_operators).
func (tv TypeAndValue) Assignable() bool
Assignable reports whether the corresponding expression is assignable to (provided a value of the right type).
func (tv TypeAndValue) HasOk() bool
HasOk reports whether the corresponding expression may be used on the rhs of a comma-ok assignment.
func (tv TypeAndValue) IsBuiltin() bool
IsBuiltin reports whether the corresponding expression denotes a (possibly parenthesized) built-in function.
func (tv TypeAndValue) IsNil() bool
IsNil reports whether the corresponding expression denotes the predeclared value nil. Depending on context, it may have been given a type different from UntypedNil.
func (tv TypeAndValue) IsType() bool
IsType reports whether the corresponding expression specifies a type.
func (tv TypeAndValue) IsValue() bool
IsValue reports whether the corresponding expression is a value. Builtins are not considered values. Constant values have a non- nil Value.
func (tv TypeAndValue) IsVoid() bool
IsVoid reports whether the corresponding expression is a function call without results.
TypeList holds a list of types.
type TypeList struct {
// contains filtered or unexported fields
}
func (l *TypeList) At(i int) Type
At returns the i'th type in the list.
func (l *TypeList) Len() int
Len returns the number of types in the list. It is safe to call on a nil receiver.
A TypeName represents a name for a (defined or alias) type.
type TypeName struct {
// contains filtered or unexported fields
}
func NewTypeName(pos syntax.Pos, pkg *Package, name string, typ Type) *TypeName
NewTypeName returns a new type name denoting the given typ. The remaining arguments set the attributes found with all Objects.
The typ argument may be a defined (Named) type or an alias type. It may also be nil such that the returned TypeName can be used as argument for NewNamed, which will set the TypeName's type as a side- effect.
func NewTypeNameLazy(pos syntax.Pos, pkg *Package, name string, load func(named *Named) (tparams []*TypeParam, underlying Type, methods []*Func)) *TypeName
NewTypeNameLazy returns a new defined type like NewTypeName, but it lazily calls resolve to finish constructing the Named object.
func (obj *TypeName) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *TypeName) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *TypeName) IsAlias() bool
IsAlias reports whether obj is an alias name for a type.
func (obj *TypeName) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *TypeName) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *TypeName) Pkg() *Package
Pkg returns the package to which the object belongs. The result is nil for labels and objects in the Universe scope.
func (obj *TypeName) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *TypeName) String() string
func (obj *TypeName) Type() Type
Type returns the object's type.
A TypeParam represents a type parameter type.
type TypeParam struct {
// contains filtered or unexported fields
}
func NewTypeParam(obj *TypeName, constraint Type) *TypeParam
NewTypeParam returns a new TypeParam. Type parameters may be set on a Named type by calling SetTypeParams. Setting a type parameter on more than one type will result in a panic.
The constraint argument can be nil, and set later via SetConstraint. If the constraint is non-nil, it must be fully defined.
func (t *TypeParam) Constraint() Type
Constraint returns the type constraint specified for t.
func (t *TypeParam) Index() int
Index returns the index of the type param within its param list, or -1 if the type parameter has not yet been bound to a type.
func (t *TypeParam) Obj() *TypeName
Obj returns the type name for the type parameter t.
func (t *TypeParam) SetConstraint(bound Type)
SetConstraint sets the type constraint for t.
It must be called by users of NewTypeParam after the bound's underlying is fully defined, and before using the type parameter in any way other than to form other types. Once SetConstraint returns the receiver, t is safe for concurrent use.
func (t *TypeParam) String() string
func (t *TypeParam) Underlying() Type
Underlying returns the underlying type of the type parameter t, which is the underlying type of its constraint. This type is always an interface.
TypeParamList holds a list of type parameters.
type TypeParamList struct {
// contains filtered or unexported fields
}
func (l *TypeParamList) At(i int) *TypeParam
At returns the i'th type parameter in the list.
func (l *TypeParamList) Len() int
Len returns the number of type parameters in the list. It is safe to call on a nil receiver.
A Union represents a union of terms embedded in an interface.
type Union struct {
// contains filtered or unexported fields
}
func NewUnion(terms []*Term) *Union
NewUnion returns a new Union type with the given terms. It is an error to create an empty union; they are syntactically not possible.
func (u *Union) Len() int
func (u *Union) String() string
func (u *Union) Term(i int) *Term
func (u *Union) Underlying() Type
A Variable represents a declared variable (including function parameters and results, and struct fields).
type Var struct {
// contains filtered or unexported fields
}
func NewField(pos syntax.Pos, pkg *Package, name string, typ Type, embedded bool) *Var
NewField returns a new variable representing a struct field. For embedded fields, the name is the unqualified type name under which the field is accessible.
func NewParam(pos syntax.Pos, pkg *Package, name string, typ Type) *Var
NewParam returns a new variable representing a function parameter.
func NewVar(pos syntax.Pos, pkg *Package, name string, typ Type) *Var
NewVar returns a new variable. The arguments set the attributes found with all Objects.
func (obj *Var) Anonymous() bool
Anonymous reports whether the variable is an embedded field. Same as Embedded; only present for backward-compatibility.
func (obj *Var) Embedded() bool
Embedded reports whether the variable is an embedded field.
func (obj *Var) Exported() bool
Exported reports whether the object is exported (starts with a capital letter). It doesn't take into account whether the object is in a local (function) scope or not.
func (obj *Var) Id() string
Id is a wrapper for Id(obj.Pkg(), obj.Name()).
func (obj *Var) IsField() bool
IsField reports whether the variable is a struct field.
func (obj *Var) Name() string
Name returns the object's (package-local, unqualified) name.
func (obj *Var) Origin() *Var
Origin returns the canonical Var for its receiver, i.e. the Var object recorded in Info.Defs.
For synthetic Vars created during instantiation (such as struct fields or function parameters that depend on type arguments), this will be the corresponding Var on the generic (uninstantiated) type. For all other Vars Origin returns the receiver.
func (obj *Var) Parent() *Scope
Parent returns the scope in which the object is declared. The result is nil for methods and struct fields.
func (obj *Var) Pkg() *Package
Pkg returns the package to which the object belongs. The result is nil for labels and objects in the Universe scope.
func (obj *Var) Pos() syntax.Pos
Pos returns the declaration position of the object's identifier.
func (obj *Var) String() string
func (obj *Var) Type() Type
Type returns the object's type.