AlgType returns the AlgKind used for comparing and hashing Type t.

AllowsGoVersion reports whether local package is allowed to use Go version major.minor.

CalcSize calculates and stores the size and alignment for t.

CalcStructSize calculates the size of t, filling in t.width, t.align, t.intRegs, and t.floatRegs, even if size calculation is otherwise disabled.

FakeRecvType returns the singleton type used for interface method receivers.

Identical reports whether t1 and t2 are identical types, following the spec rules.

IdenticalIgnoreTags is like Identical, but it ignores struct tags for struct identity.

IdenticalStrict is like Identical, but matches types exactly, without the exception for shapes.

IncomparableField returns an incomparable Field of struct Type t, if any.

IsComparable reports whether t is a comparable type.

Can this type be stored directly in an interface word? Yes, if the representation is a single pointer.

IsExported reports whether name is an exported Go symbol (that is, whether it begins with an upper-case letter).

IsInterfaceMethod reports whether (field) m is an interface method.

IsMethodApplicable reports whether method m can be called on a value of type t.

IsNoInstrumentPkg reports whether p is a package that should not be instrumented.

IsNoRacePkg reports whether p is a package that should not be race instrumented.

IsPaddedField reports whether the i'th field of struct type t is followed by padding.

IsReflexive reports whether t has a reflexive equality operator.

NewArray returns a new fixed-length array Type.

NewChan returns a new chan Type with direction dir.

NewChanArgs returns a new TCHANARGS type for channel type c.

NewFuncArgs returns a new TFUNCARGS type for func type f.

NewInterface returns a new interface for the given methods and embedded types.

NewMap returns a new map Type with key type k and element (aka value) type v.

NewNamed returns a new named type for the given type name.

NewPkg returns a new Pkg for the given package path and name.

NewPtr returns the pointer type pointing to t.

NewSignature returns a new function type for the given receiver, parameters, and results, any of which may be nil.

NewSlice returns the slice Type with element type elem.

NewStruct returns a new struct with the given fields.

ParseLangFlag verifies that the -lang flag holds a valid value, and exits if not.

PtrDataSize returns the length in bytes of the prefix of t containing pointer data.

ReceiverBaseType returns the underlying type, if any, that owns methods with receiver parameter t.

ReflectSymName returns the name of s if it's in package "reflect"; otherwise it returns "".

RoundUp rounds o to a multiple of r, r is a power of 2.

RuntimeSymName returns the name of s if it's in package "runtime"; otherwise it returns "".

SplitVargenSuffix returns name split into a base string and a ·N suffix, if any.

SubstAny walks t, replacing instances of "any" with successive elements removed from types.

TypeHash computes a hash value for type t to use in type switch statements.

TypeHasNoAlg reports whether t does not have any associated hash/eq algorithms because t, or some component of t, is marked Noalg.

Type can be compared/hashed as regular memory.

Type needs special comparison/hashing functions.

types of channel must match ../../../../reflect/type.go:/ChanDir.

pseudo-types used temporarily only during frame layout (CalcSize()).

untyped numeric constants.

multiple types; the result of calling a function or method, with a memory at the end.

internal types used by SSA backend (flags, memory, etc.).

a pair of types, used by SSA backend.

Predeclared alias types.

BlankSym is the blank (_) symbol.

BuiltinPkg is a fake package that declares the universe block.

CalcSizeDisabled indicates whether it is safe to calculate Types' widths and alignments.

Predeclared comparable interface type.

DefaultKinds maps from a constant.Kind to its default Kind.

Predeclared error interface type.

LocalPkg is the package being compiled.

MaxWidth is the maximum size of a value on the target architecture.

NewPtrCacheEnabled controls whether *T Types are cached in T.

numImport tracks how often a package with a given name is imported.

Fake package for shape types (see typecheck.Shapify()).

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.

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.

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.

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.

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.

TSSA types.

Types stores pointers to predeclared named types.

UnsafePkg is package unsafe.

Types to represent untyped numeric constants.

Types to represent untyped string and boolean constants.

UntypedTypes maps from a constant.Kind to its untyped Type representation.

Array contains Type fields specific to array types.

Chan contains Type fields specific to channel types.

ChanArgs contains Type fields specific to TCHANARGS types.

A Field is a (Sym, Type) pairing along with some other information, and, depending on the context, is used to represent: - a field in a struct - a method in an interface or associated with a named type - a function parameter.

Forward contains Type fields specific to forward types.

Func contains Type fields specific to func types.

// FuncArgs contains Type fields specific to TFUNCARGS types.

Interface contains Type fields specific to interface types.

Map contains Type fields specific to maps.

Ptr contains Type fields specific to pointer types.

Results are the output from calls that will be late-expanded.

Slice contains Type fields specific to slice types.

StructType contains Type fields specific to struct types.

Sym represents an object name in a segmented (pkg, name) namespace.

A Type represents a Go type.

Object represents an ir.Node, but without needing to import github.com/go-asm/go/cmd/compile/ir, which would cause an import cycle.

AlgKind describes the kind of algorithms used for comparing and hashing a Type.

ChanDir is whether a channel can send, receive, or both.

Cmp is a comparison between values a and b.

EmbeddedsByName sorts embedded types by name.

Kind describes a kind of type.

MethodsByName sorts methods by name.