const (
CMPlt = Cmp(-1)
CMPeq = Cmp(0)
CMPgt = Cmp(1)
)
const (
IgnoreBlankFields componentsIncludeBlankFields = false
CountBlankFields componentsIncludeBlankFields = true
)
const BADWIDTH = -1000000000
Slices in the runtime are represented by three components:
type slice struct {
ptr unsafe.Pointer
len int
cap int
}
Strings in the runtime are represented by two components:
type string struct {
ptr unsafe.Pointer
len int
}
These variables are the offsets of fields and sizes of these structs.
var (
SlicePtrOffset int64
SliceLenOffset int64
SliceCapOffset int64
SliceSize int64
StringSize int64
)
var (
// Predeclared alias types. These are actually created as distinct
// defined types for better error messages, but are then specially
// treated as identical to their respective underlying types.
AnyType *Type
ByteType *Type
RuneType *Type
// Predeclared error interface type.
ErrorType *Type
// Predeclared comparable interface type.
ComparableType *Type
// Types to represent untyped string and boolean constants.
UntypedString = newType(TSTRING)
UntypedBool = newType(TBOOL)
// Types to represent untyped numeric constants.
UntypedInt = newType(TIDEAL)
UntypedRune = newType(TIDEAL)
UntypedFloat = newType(TIDEAL)
UntypedComplex = newType(TIDEAL)
)
var (
// TSSA types. HasPointers assumes these are pointer-free.
TypeInvalid = newSSA("invalid")
TypeMem = newSSA("mem")
TypeFlags = newSSA("flags")
TypeVoid = newSSA("void")
TypeInt128 = newSSA("int128")
TypeResultMem = newResults([]*Type{TypeMem})
)
var (
IsInt [NTYPE]bool
IsFloat [NTYPE]bool
IsComplex [NTYPE]bool
IsSimple [NTYPE]bool
)
var BasicTypeNames = []string{ TINT: "int", TUINT: "uint", TINT8: "int8", TUINT8: "uint8", TINT16: "int16", TUINT16: "uint16", TINT32: "int32", TUINT32: "uint32", TINT64: "int64", TUINT64: "uint64", TUINTPTR: "uintptr", TFLOAT32: "float32", TFLOAT64: "float64", TCOMPLEX64: "complex64", TCOMPLEX128: "complex128", TBOOL: "bool", TANY: "any", TSTRING: "string", TNIL: "nil", TIDEAL: "untyped number", TBLANK: "blank", }
CalcSizeDisabled indicates whether it is safe to calculate Types' widths and alignments. See CalcSize.
var CalcSizeDisabled bool
DefaultKinds maps from a constant.Kind to its default Kind.
var DefaultKinds = [...]Kind{ constant.Bool: TBOOL, constant.String: TSTRING, constant.Int: TINT, constant.Float: TFLOAT64, constant.Complex: TCOMPLEX128, }
var IsOrdered [NTYPE]bool
MaxWidth is the maximum size of a value on the target architecture.
var MaxWidth int64
NewPtrCacheEnabled controls whether *T Types are cached in T. Caching is disabled just before starting the backend. This allows the backend to run concurrently.
var NewPtrCacheEnabled = true
numImport tracks how often a package with a given name is imported. It is used to provide a better error message (by using the package path to disambiguate) if a package that appears multiple times with the same name appears in an error message.
var NumImport = make(map[string]int)
var PtrSize int
var RegSize int
Fake package for shape types (see typecheck.Shapify()).
var ShapePkg = NewPkg("go.shape", "go.shape")
var SimType [NTYPE]Kind
var SkipSizeForTracing bool
Types stores pointers to predeclared named types.
It also stores pointers to several special types:
var Types [NTYPE]*Type
UntypedTypes maps from a constant.Kind to its untyped Type representation.
var UntypedTypes = [...]*Type{ constant.Bool: UntypedBool, constant.String: UntypedString, constant.Int: UntypedInt, constant.Float: UntypedFloat, constant.Complex: UntypedComplex, }
func AllowsGoVersion(major, minor int) bool
AllowsGoVersion reports whether local package is allowed to use Go version major.minor.
func CalcSize(t *Type)
CalcSize calculates and stores the size, alignment, eq/hash algorithm, and ptrBytes for t. If CalcSizeDisabled is set, and the size/alignment have not already been calculated, it calls Fatal. This is used to prevent data races in the back end.
func CalcStructSize(t *Type)
CalcStructSize calculates the size of t, filling in t.width, t.align, t.intRegs, and t.floatRegs, even if size calculation is otherwise disabled.
func CheckSize(t *Type)
func DeferCheckSize()
func Identical(t1, t2 *Type) bool
Identical reports whether t1 and t2 are identical types, following the spec rules. Receiver parameter types are ignored. Named (defined) types are only equal if they are pointer-equal - i.e. there must be a unique types.Type for each specific named type. Also, a type containing a shape type is considered identical to another type (shape or not) if their underlying types are the same, or they are both pointers.
func IdenticalIgnoreTags(t1, t2 *Type) bool
IdenticalIgnoreTags is like Identical, but it ignores struct tags for struct identity.
func IdenticalStrict(t1, t2 *Type) bool
IdenticalStrict is like Identical, but matches types exactly, without the exception for shapes.
func InitTypes(defTypeName func(sym *Sym, typ *Type) Object)
func InternString(b []byte) string
func IsComparable(t *Type) bool
IsComparable reports whether t is a comparable type.
func IsDirectIface(t *Type) bool
Can this type be stored directly in an interface word? Yes, if the representation is a single pointer.
func IsExported(name string) bool
IsExported reports whether name is an exported Go symbol (that is, whether it begins with an upper-case letter).
func IsInterfaceMethod(f *Type) bool
IsInterfaceMethod reports whether (field) m is an interface method. Such methods have the special receiver type types.FakeRecvType().
func IsMethodApplicable(t *Type, m *Field) bool
IsMethodApplicable reports whether method m can be called on a value of type t. This is necessary because we compute a single method set for both T and *T, but some *T methods are not applicable to T receivers.
func IsNoInstrumentPkg(p *Pkg) bool
IsNoInstrumentPkg reports whether p is a package that should not be instrumented.
func IsNoRacePkg(p *Pkg) bool
IsNoRacePkg reports whether p is a package that should not be race instrumented.
func IsPaddedField(t *Type, i int) bool
IsPaddedField reports whether the i'th field of struct type t is followed by padding.
func IsReflexive(t *Type) bool
IsReflexive reports whether t has a reflexive equality operator. That is, if x==x for all x of type t.
func IsRuntimePkg(p *Pkg) bool
IsRuntimePkg reports whether p is a runtime package.
func ParseLangFlag()
ParseLangFlag verifies that the -lang flag holds a valid value, and exits if not. It initializes data used by AllowsGoVersion.
func PkgMap() map[string]*Pkg
func PtrDataSize(t *Type) int64
PtrDataSize returns the length in bytes of the prefix of t containing pointer data. Anything after this offset is scalar data.
PtrDataSize is only defined for actual Go types. It's an error to use it on compiler-internal types (e.g., TSSA, TRESULTS).
func ReflectSymName(s *Sym) string
ReflectSymName returns the name of s if it's in package "reflect"; otherwise it returns "".
func ResumeCheckSize()
func RoundUp(o int64, r int64) int64
RoundUp rounds o to a multiple of r, r is a power of 2.
func RuntimeSymName(s *Sym) string
RuntimeSymName returns the name of s if it's in package "runtime"; otherwise it returns "".
func SplitVargenSuffix(name string) (base, suffix string)
SplitVargenSuffix returns name split into a base string and a ·N suffix, if any.
func TypeHasNoAlg(t *Type) bool
TypeHasNoAlg reports whether t does not have any associated hash/eq algorithms because t, or some component of t, is marked Noalg.
func TypeHash(t *Type) uint32
TypeHash computes a hash value for type t to use in type switch statements.
func TypeSymName(t *Type) string
AlgKind describes the kind of algorithms used for comparing and hashing a Type.
type AlgKind int8
const (
AUNK AlgKind = iota
ANOEQ // Types cannot be compared
ANOALG // implies ANOEQ, and in addition has a part that is marked Noalg
AMEM // Type can be compared/hashed as regular memory.
AMEM0 // Specific subvariants of AMEM (TODO: move to ../reflectdata?)
AMEM8
AMEM16
AMEM32
AMEM64
AMEM128
ASTRING
AINTER
ANILINTER
AFLOAT32
AFLOAT64
ACPLX64
ACPLX128
ASPECIAL // Type needs special comparison/hashing functions.
)
func AlgType(t *Type) AlgKind
AlgType returns the AlgKind used for comparing and hashing Type t.
func (i AlgKind) String() string
Array contains Type fields specific to array types.
type Array struct {
Elem *Type // element type
Bound int64 // number of elements; <0 if unknown yet
}
Chan contains Type fields specific to channel types.
type Chan struct {
Elem *Type // element type
Dir ChanDir // channel direction
}
ChanArgs contains Type fields specific to TCHANARGS types.
type ChanArgs struct {
T *Type // reference to a chan type whose elements need a width check
}
ChanDir is whether a channel can send, receive, or both.
type ChanDir uint8
const (
// types of channel
// must match ../../../../reflect/type.go:/ChanDir
Crecv ChanDir = 1 << 0
Csend ChanDir = 1 << 1
Cboth ChanDir = Crecv | Csend
)
func (c ChanDir) CanRecv() bool
func (c ChanDir) CanSend() bool
Cmp is a comparison between values a and b.
-1 if a < b 0 if a == b 1 if a > b
type Cmp int8
EmbeddedsByName sorts embedded types by name.
type EmbeddedsByName []*Field
func (x EmbeddedsByName) Len() int
func (x EmbeddedsByName) Less(i, j int) bool
func (x EmbeddedsByName) Swap(i, j int)
A Field is a (Sym, Type) pairing along with some other information, and, depending on the context, is used to represent:
type Field struct {
Embedded uint8 // embedded field
Pos src.XPos
// Name of field/method/parameter. Can be nil for interface fields embedded
// in interfaces and unnamed parameters.
Sym *Sym
Type *Type // field type
Note string // literal string annotation
// For fields that represent function parameters, Nname points to the
// associated ONAME Node. For fields that represent methods, Nname points to
// the function name node.
Nname Object
// Offset in bytes of this field or method within its enclosing struct
// or interface Type. For parameters, this is BADWIDTH.
Offset int64
// contains filtered or unexported fields
}
func FakeRecv() *Field
func IncomparableField(t *Type) *Field
IncomparableField returns an incomparable Field of struct Type t, if any.
func NewField(pos src.XPos, sym *Sym, typ *Type) *Field
func (f *Field) Copy() *Field
func (f *Field) End() int64
End returns the offset of the first byte immediately after this field.
func (f *Field) IsDDD() bool
func (f *Field) IsMethod() bool
IsMethod reports whether f represents a method rather than a struct field.
func (f *Field) Nointerface() bool
func (f *Field) SetIsDDD(b bool)
func (f *Field) SetNointerface(b bool)
Forward contains Type fields specific to forward types.
type Forward struct {
Copyto []*Type // where to copy the eventual value to
Embedlineno src.XPos // first use of this type as an embedded type
}
Func contains Type fields specific to func types.
type Func struct {
// Argwid is the total width of the function receiver, params, and results.
// It gets calculated via a temporary TFUNCARGS type.
// Note that TFUNC's Width is Widthptr.
Argwid int64
// contains filtered or unexported fields
}
// FuncArgs contains Type fields specific to TFUNCARGS types.
type FuncArgs struct {
T *Type // reference to a func type whose elements need a width check
}
Interface contains Type fields specific to interface types.
type Interface struct {
}
Kind describes a kind of type.
type Kind uint8
const (
Txxx Kind = iota
TINT8
TUINT8
TINT16
TUINT16
TINT32
TUINT32
TINT64
TUINT64
TINT
TUINT
TUINTPTR
TCOMPLEX64
TCOMPLEX128
TFLOAT32
TFLOAT64
TBOOL
TPTR
TFUNC
TSLICE
TARRAY
TSTRUCT
TCHAN
TMAP
TINTER
TFORW
TANY
TSTRING
TUNSAFEPTR
// pseudo-types for literals
TIDEAL // untyped numeric constants
TNIL
TBLANK
// pseudo-types used temporarily only during frame layout (CalcSize())
TFUNCARGS
TCHANARGS
// SSA backend types
TSSA // internal types used by SSA backend (flags, memory, etc.)
TTUPLE // a pair of types, used by SSA backend
TRESULTS // multiple types; the result of calling a function or method, with a memory at the end.
NTYPE
)
func (i Kind) String() string
Map contains Type fields specific to maps.
type Map struct {
Key *Type // Key type
Elem *Type // Val (elem) type
Bucket *Type // internal struct type representing a hash bucket
}
MethodsByName sorts methods by name.
type MethodsByName []*Field
func (x MethodsByName) Len() int
func (x MethodsByName) Less(i, j int) bool
func (x MethodsByName) Swap(i, j int)
Object represents an ir.Node, but without needing to import cmd/compile/internal/ir, which would cause an import cycle. The uses in other packages must type assert values of type Object to ir.Node or a more specific type.
type Object interface {
Pos() src.XPos
Sym() *Sym
Type() *Type
}
type Pkg struct {
Path string // string literal used in import statement, e.g. "runtime/internal/sys"
Name string // package name, e.g. "sys"
Prefix string // escaped path for use in symbol table
Syms map[string]*Sym
Pathsym *obj.LSym
Direct bool // imported directly
}
BuiltinPkg is a fake package that declares the universe block.
var BuiltinPkg *Pkg
LocalPkg is the package being compiled.
var LocalPkg *Pkg
UnsafePkg is package unsafe.
var UnsafePkg *Pkg
func NewPkg(path, name string) *Pkg
NewPkg returns a new Pkg for the given package path and name. Unless name is the empty string, if the package exists already, the existing package name and the provided name must match.
func (pkg *Pkg) Lookup(name string) *Sym
func (pkg *Pkg) LookupBytes(name []byte) *Sym
func (pkg *Pkg) LookupNum(prefix string, n int) *Sym
LookupNum looks up the symbol starting with prefix and ending with the decimal n. If prefix is too long, LookupNum panics.
func (pkg *Pkg) LookupOK(name string) (s *Sym, existed bool)
LookupOK looks up name in pkg and reports whether it previously existed.
func (pkg *Pkg) Selector(name string) *Sym
Selector looks up a selector identifier.
Ptr contains Type fields specific to pointer types.
type Ptr struct {
Elem *Type // element type
}
Results are the output from calls that will be late-expanded.
type Results struct {
Types []*Type // Last element is memory output from call.
}
Slice contains Type fields specific to slice types.
type Slice struct {
Elem *Type // element type
}
StructType contains Type fields specific to struct types.
type Struct struct {
// Maps have three associated internal structs (see struct MapType).
// Map links such structs back to their map type.
Map *Type
ParamTuple bool // whether this struct is actually a tuple of signature parameters
// contains filtered or unexported fields
}
Sym represents an object name in a segmented (pkg, name) namespace. Most commonly, this is a Go identifier naming an object declared within a package, but Syms are also used to name internal synthesized objects.
As an exception, field and method names that are exported use the Sym associated with localpkg instead of the package that declared them. This allows using Sym pointer equality to test for Go identifier uniqueness when handling selector expressions.
Ideally, Sym should be used for representing Go language constructs, while cmd/internal/obj.LSym is used for representing emitted artifacts.
NOTE: In practice, things can be messier than the description above for various reasons (historical, convenience).
type Sym struct {
Linkname string // link name
Pkg *Pkg
Name string // object name
// The unique ONAME, OTYPE, OPACK, or OLITERAL node that this symbol is
// bound to within the current scope. (Most parts of the compiler should
// prefer passing the Node directly, rather than relying on this field.)
//
// Deprecated: New code should avoid depending on Sym.Def. Add
// mdempsky@ as a reviewer for any CLs involving Sym.Def.
Def Object
// contains filtered or unexported fields
}
BlankSym is the blank (_) symbol.
var BlankSym *Sym
func TypeSym(t *Type) *Sym
func TypeSymLookup(name string) *Sym
func (sym *Sym) Asm() bool
func (s *Sym) Format(f fmt.State, verb rune)
Format implements formatting for a Sym. The valid formats are:
%v Go syntax: Name for symbols in the local package, PkgName.Name for imported symbols. %+v Debug syntax: always include PkgName. prefix even for local names. %S Short syntax: Name only, no matter what.
func (sym *Sym) Func() bool
func (sym *Sym) IsBlank() bool
func (a *Sym) Less(b *Sym) bool
Less reports whether symbol a is ordered before symbol b.
Symbols are ordered exported before non-exported, then by name, and finally (for non-exported symbols) by package path.
func (sym *Sym) Linksym() *obj.LSym
Deprecated: This method should not be used directly. Instead, use a higher-level abstraction that directly returns the linker symbol for a named object. For example, reflectdata.TypeLinksym(t) instead of reflectdata.TypeSym(t).Linksym().
func (sym *Sym) LinksymABI(abi obj.ABI) *obj.LSym
Deprecated: This method should not be used directly. Instead, use a higher-level abstraction that directly returns the linker symbol for a named object. For example, (*ir.Name).LinksymABI(abi) instead of (*ir.Name).Sym().LinksymABI(abi).
func (sym *Sym) OnExportList() bool
func (sym *Sym) SetAsm(b bool)
func (sym *Sym) SetFunc(b bool)
func (sym *Sym) SetOnExportList(b bool)
func (sym *Sym) SetSiggen(b bool)
func (sym *Sym) SetUniq(b bool)
func (sym *Sym) Siggen() bool
func (s *Sym) String() string
func (sym *Sym) Uniq() bool
type Tuple struct {
// contains filtered or unexported fields
}
A Type represents a Go type.
There may be multiple unnamed types with identical structure. However, there must be a unique Type object for each unique named (defined) type. After noding, a package-level type can be looked up by building its unique symbol sym (sym = package.Lookup(name)) and checking sym.Def. If sym.Def is non-nil, the type already exists at package scope and is available at sym.Def.(*ir.Name).Type(). Local types (which may have the same name as a package-level type) are distinguished by their vargen, which is embedded in their symbol name.
type Type struct {
// contains filtered or unexported fields
}
func ComplexForFloat(t *Type) *Type
func FakeRecvType() *Type
FakeRecvType returns the singleton type used for interface method receivers.
func FloatForComplex(t *Type) *Type
func NewArray(elem *Type, bound int64) *Type
NewArray returns a new fixed-length array Type.
func NewChan(elem *Type, dir ChanDir) *Type
NewChan returns a new chan Type with direction dir.
func NewChanArgs(c *Type) *Type
NewChanArgs returns a new TCHANARGS type for channel type c.
func NewFuncArgs(f *Type) *Type
NewFuncArgs returns a new TFUNCARGS type for func type f.
func NewInterface(methods []*Field) *Type
NewInterface returns a new interface for the given methods and embedded types. Embedded types are specified as fields with no Sym.
func NewMap(k, v *Type) *Type
NewMap returns a new map Type with key type k and element (aka value) type v.
func NewNamed(obj Object) *Type
NewNamed returns a new named type for the given type name. obj should be an ir.Name. The new type is incomplete (marked as TFORW kind), and the underlying type should be set later via SetUnderlying(). References to the type are maintained until the type is filled in, so those references can be updated when the type is complete.
func NewPtr(elem *Type) *Type
NewPtr returns the pointer type pointing to t.
func NewResults(types []*Type) *Type
func NewSignature(recv *Field, params, results []*Field) *Type
NewSignature returns a new function type for the given receiver, parameters, and results, any of which may be nil.
func NewSlice(elem *Type) *Type
NewSlice returns the slice Type with element type elem.
func NewStruct(fields []*Field) *Type
NewStruct returns a new struct with the given fields.
func NewTuple(t1, t2 *Type) *Type
func ReceiverBaseType(t *Type) *Type
ReceiverBaseType returns the underlying type, if any, that owns methods with receiver parameter t. The result is either a named type or an anonymous struct.
func SubstAny(t *Type, types *[]*Type) *Type
SubstAny walks t, replacing instances of "any" with successive elements removed from types. It returns the substituted type.
func (t *Type) Alignment() int64
func (t *Type) AllMethods() []*Field
AllMethods returns a pointer to all the methods (including embedding) for type t. For an interface type, this is the set of methods that are typically iterated over. For non-interface types, AllMethods() only returns a valid result after CalcMethods() has been called at least once.
func (t *Type) ArgWidth() int64
ArgWidth returns the total aligned argument size for a function. It includes the receiver, parameters, and results.
func (*Type) CanBeAnSSAAux()
func (t *Type) ChanArgs() *Type
ChanArgs returns the channel type for TCHANARGS type t.
func (t *Type) ChanDir() ChanDir
ChanDir returns the direction of a channel type t. The direction will be one of Crecv, Csend, or Cboth.
func (t *Type) Compare(x *Type) Cmp
Compare compares types for purposes of the SSA back end, returning a Cmp (one of CMPlt, CMPeq, CMPgt). The answers are correct for an optimizer or code generator, but not necessarily typechecking. The order chosen is arbitrary, only consistency and division into equivalence classes (Types that compare CMPeq) matters.
func (t *Type) Deferwidth() bool
func (t *Type) Elem() *Type
Elem returns the type of elements of t. Usable with pointers, channels, arrays, slices, and maps.
func (t *Type) Field(i int) *Field
Field returns the i'th field of struct type t.
func (t *Type) FieldName(i int) string
func (t *Type) FieldOff(i int) int64
func (t *Type) FieldType(i int) *Type
func (t *Type) Fields() []*Field
Fields returns a slice of containing all fields of a struct type t.
func (t *Type) Format(s fmt.State, verb rune)
Format implements formatting for a Type. The valid formats are:
%v Go syntax %+v Debug syntax: Go syntax with a KIND- prefix for all but builtins. %L Go syntax for underlying type if t is named %S short Go syntax: drop leading "func" in function type %-S special case for method receiver symbol
func (t *Type) FuncArgs() *Type
FuncArgs returns the func type for TFUNCARGS type t.
func (t *Type) HasNil() bool
HasNil reports whether the set of values determined by t includes nil.
func (t *Type) HasPointers() bool
HasPointers reports whether t contains a heap pointer. Note that this function ignores pointers to not-in-heap types.
func (t *Type) HasShape() bool
func (t *Type) IsArray() bool
func (t *Type) IsBoolean() bool
func (t *Type) IsChan() bool
func (t *Type) IsComplex() bool
func (t *Type) IsEmptyInterface() bool
IsEmptyInterface reports whether t is an empty interface type.
func (t *Type) IsFlags() bool
func (t *Type) IsFloat() bool
func (t *Type) IsFullyInstantiated() bool
IsFullyInstantiated reports whether t is a fully instantiated generic type; i.e. an instantiated generic type where all type arguments are non-generic or fully instantiated generic types.
func (t *Type) IsFuncArgStruct() bool
IsFuncArgStruct reports whether t is a struct representing function parameters or results.
func (t *Type) IsInteger() bool
func (t *Type) IsInterface() bool
func (t *Type) IsKind(et Kind) bool
IsKind reports whether t is a Type of the specified kind.
func (t *Type) IsMap() bool
func (t *Type) IsMemory() bool
func (t *Type) IsPtr() bool
IsPtr reports whether t is a regular Go pointer type. This does not include unsafe.Pointer.
func (t *Type) IsPtrElem() bool
IsPtrElem reports whether t is the element of a pointer (to t).
func (t *Type) IsPtrShaped() bool
IsPtrShaped reports whether t is represented by a single machine pointer. In addition to regular Go pointer types, this includes map, channel, and function types and unsafe.Pointer. It does not include array or struct types that consist of a single pointer shaped type. TODO(mdempsky): Should it? See golang.org/issue/15028.
func (t *Type) IsResults() bool
func (t *Type) IsScalar() bool
IsScalar reports whether 't' is a scalar Go type, e.g. bool/int/float/complex. Note that struct and array types consisting of a single scalar element are not considered scalar, likewise pointer types are also not considered scalar.
func (t *Type) IsShape() bool
func (t *Type) IsSigned() bool
func (t *Type) IsSlice() bool
func (t *Type) IsString() bool
func (t *Type) IsStruct() bool
func (t *Type) IsTuple() bool
func (t *Type) IsUintptr() bool
IsUintptr reports whether t is a uintptr.
func (t *Type) IsUnsafePtr() bool
IsUnsafePtr reports whether t is an unsafe pointer.
func (t *Type) IsUnsigned() bool
func (t *Type) IsUntyped() bool
IsUntyped reports whether t is an untyped type.
func (t *Type) IsVariadic() bool
IsVariadic reports whether function type t is variadic.
func (t *Type) IsVoid() bool
func (t *Type) Key() *Type
Key returns the key type of map type t.
func (t *Type) Kind() Kind
Kind returns the kind of type t.
func (t *Type) LinkString() string
LinkString returns a string description of t, suitable for use in link symbols.
The description corresponds to type identity. That is, for any pair of types t1 and t2, Identical(t1, t2) == (t1.LinkString() == t2.LinkString()) is true. Thus it's safe to use as a map key to implement a type-identity-keyed map.
func (t *Type) MapType() *Map
MapType returns t's extra map-specific fields.
func (t *Type) Methods() []*Field
Methods returns a pointer to the base methods (excluding embedding) for type t. These can either be concrete methods (for non-interface types) or interface methods (for interface types).
func (t *Type) NameString() string
NameString generates a user-readable, mostly unique string description of t. NameString always returns the same description for identical types, even across compilation units.
NameString qualifies identifiers by package name, so it has collisions when different packages share the same names and identifiers. It also does not distinguish function-scope defined types from package-scoped defined types or from each other.
func (t *Type) Noalg() bool
func (t *Type) NotInHeap() bool
func (t *Type) NumComponents(countBlank componentsIncludeBlankFields) int64
NumComponents returns the number of primitive elements that compose t. Struct and array types are flattened for the purpose of counting. All other types (including string, slice, and interface types) count as one element. If countBlank is IgnoreBlankFields, then blank struct fields (and their comprised elements) are excluded from the count. struct { x, y [3]int } has six components; [10]struct{ x, y string } has twenty.
func (t *Type) NumElem() int64
func (t *Type) NumFields() int
func (t *Type) NumParams() int
func (t *Type) NumRecvs() int
func (t *Type) NumResults() int
func (t *Type) Obj() Object
Obj returns the canonical type name node for a named type t, nil for an unnamed type.
func (t *Type) OffsetOf(name string) int64
OffsetOf reports the offset of the field of a struct. The field is looked up by name.
func (t *Type) Param(i int) *Field
Param returns the i'th parameter of signature type t.
func (t *Type) Params() []*Field
Params returns a slice of regular parameters of signature type t.
func (t *Type) ParamsResults() []*Field
ParamsResults returns a slice containing the signature's (normal) parameters followed by its results.
func (t *Type) Pos() src.XPos
Pos returns a position associated with t, if any. This should only be used for diagnostics.
func (t *Type) PtrTo() *Type
func (t *Type) RParams() []*Type
func (t *Type) Recur() bool
func (t *Type) Recv() *Field
Recv returns the receiver of function type t, if any.
func (t *Type) RecvParams() []*Field
RecvParams returns a slice containing the signature's receiver (if any) followed by its (normal) parameters.
func (t *Type) RecvParamsResults() []*Field
RecvParamsResults returns a slice containing all of the signature's parameters in receiver (if any), (normal) parameters, and then results.
func (t *Type) Recvs() []*Field
Recvs returns a slice of receiver parameters of signature type t. The returned slice always has length 0 or 1.
func (t *Type) Registers() (uint8, uint8)
Registers returns the number of integer and floating-point registers required to represent a parameter of this type under the ABIInternal calling conventions.
If t must be passed by memory, Registers returns (math.MaxUint8, math.MaxUint8).
func (t *Type) Result(i int) *Field
Result returns the i'th result of signature type t.
func (t *Type) Results() []*Field
Results returns a slice of result parameters of signature type t.
func (t *Type) ResultsTuple() *Type
ResultsTuple returns the result type of signature type t as a tuple. This can be used as the type of multi-valued call expressions.
func (t *Type) SetAllMethods(fs []*Field)
SetAllMethods sets the set of all methods for type t (i.e., including promoted methods from embedded types).
func (t *Type) SetDeferwidth(b bool)
func (t *Type) SetHasShape(b bool)
func (t *Type) SetInterface(methods []*Field)
SetInterface sets the base methods of an interface type t.
func (t *Type) SetIsShape(b bool)
Should always do SetHasShape(true) when doing SetIsShape(true).
func (t *Type) SetMethods(fs []*Field)
SetMethods sets the direct method set for type t (i.e., *not* including promoted methods from embedded types).
func (t *Type) SetNoalg(b bool)
func (t *Type) SetNotInHeap(b bool)
func (t *Type) SetRParams(rparams []*Type)
func (t *Type) SetRecur(b bool)
func (t *Type) SetUnderlying(underlying *Type)
SetUnderlying sets the underlying type of an incomplete type (i.e. type whose kind is currently TFORW). SetUnderlying automatically updates any types that were waiting for this type to be completed.
func (t *Type) SimpleString() string
func (t *Type) Size() int64
func (t *Type) SoleComponent() *Type
SoleComponent returns the only primitive component in t, if there is exactly one. Otherwise, it returns nil. Components are counted as in NumComponents, including blank fields. Keep in sync with cmd/compile/internal/walk/convert.go:soleComponent.
func (t *Type) String() string
String returns the Go syntax for the type t.
func (t *Type) StructType() *Struct
StructType returns t's extra struct-specific fields.
func (t *Type) Sym() *Sym
Sym returns the name of type t.
func (t *Type) ToUnsigned() *Type
ToUnsigned returns the unsigned equivalent of integer type t.
func (t *Type) Underlying() *Type
Underlying returns the underlying type of type t.