type internal/abi.Type

190 uses

	internal/abi (current package)
		iface.go#L16: 	Type  *Type
		iface.go#L25: 	Type *Type
		type.go#L20: type Type struct {
		type.go#L170: func TypeOf(a any) *Type {
		type.go#L177: 	return (*Type)(NoEscape(unsafe.Pointer(eface.Type)))
		type.go#L181: func TypeFor[T any]() *Type {
		type.go#L189: func (t *Type) Kind() Kind { return t.Kind_ & KindMask }
		type.go#L191: func (t *Type) HasName() bool {
		type.go#L196: func (t *Type) Pointers() bool { return t.PtrBytes != 0 }
		type.go#L199: func (t *Type) IfaceIndir() bool {
		type.go#L204: func (t *Type) IsDirectIface() bool {
		type.go#L208: func (t *Type) GcSlice(begin, end uintptr) []byte {
		type.go#L265: 	Type
		type.go#L266: 	Elem  *Type // array element type
		type.go#L267: 	Slice *Type // slice type
		type.go#L272: func (t *Type) Len() int {
		type.go#L279: func (t *Type) Common() *Type {
		type.go#L294: 	Type
		type.go#L295: 	Elem *Type
		type.go#L305: func (t *Type) ChanDir() ChanDir {
		type.go#L314: func (t *Type) Uncommon() *UncommonType {
		type.go#L365: 			Type
		type.go#L373: func (t *Type) Elem() *Type {
		type.go#L395: func (t *Type) StructType() *StructType {
		type.go#L403: func (t *Type) MapType() *MapType {
		type.go#L411: func (t *Type) ArrayType() *ArrayType {
		type.go#L419: func (t *Type) FuncType() *FuncType {
		type.go#L427: func (t *Type) InterfaceType() *InterfaceType {
		type.go#L435: func (t *Type) Size() uintptr { return t.Size_ }
		type.go#L438: func (t *Type) Align() int { return int(t.Align_) }
		type.go#L440: func (t *Type) FieldAlign() int { return int(t.FieldAlign_) }
		type.go#L443: 	Type
		type.go#L448: func (t *Type) ExportedMethods() []Method {
		type.go#L456: func (t *Type) NumMethod() int {
		type.go#L468: 	Type
		type.go#L469: 	Key    *Type
		type.go#L470: 	Elem   *Type
		type.go#L471: 	Bucket *Type // internal type representing a hash bucket
		type.go#L498: func (t *Type) Key() *Type {
		type.go#L506: 	Type
		type.go#L507: 	Elem *Type // slice element type
		type.go#L522: 	Type
		type.go#L527: func (t *FuncType) In(i int) *Type {
		type.go#L539: func (t *FuncType) Out(i int) *Type {
		type.go#L543: func (t *FuncType) InSlice() []*Type {
		type.go#L551: 	return (*[1 << 16]*Type)(addChecked(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.InCount:t.InCount]
		type.go#L553: func (t *FuncType) OutSlice() []*Type {
		type.go#L562: 	return (*[1 << 17]*Type)(addChecked(unsafe.Pointer(t), uadd, "outCount > 0"))[t.InCount : t.InCount+outCount : t.InCount+outCount]
		type.go#L570: 	Type
		type.go#L571: 	Elem *Type // pointer element (pointed at) type
		type.go#L576: 	Typ    *Type   // type of field
		type.go#L585: 	Type

	internal/reflectlite
		type.go#L66: 	common() *abi.Type
		type.go#L95: 	*abi.Type
		type.go#L237: func (t rtype) typeOff(off typeOff) *abi.Type {
		type.go#L238: 	return (*abi.Type)(resolveTypeOff(unsafe.Pointer(t.Type), int32(off)))
		type.go#L253: func (t rtype) common() *abi.Type { return t.Type }
		type.go#L301: func toRType(t *abi.Type) rtype {
		type.go#L305: func elem(t *abi.Type) *abi.Type {
		type.go#L414: func implements(T, V *abi.Type) bool {
		type.go#L505: func directlyAssignable(T, V *abi.Type) bool {
		type.go#L521: func haveIdenticalType(T, V *abi.Type, cmpTags bool) bool {
		type.go#L533: func haveIdenticalUnderlyingType(T, V *abi.Type, cmpTags bool) bool {
		type.go#L638: func toType(t *abi.Type) Type {
		value.go#L39: 	typ_ *abi.Type
		value.go#L91: func (v Value) typ() *abi.Type {
		value.go#L97: 	return (*abi.Type)(abi.NoEscape(unsafe.Pointer(v.typ_)))
		value.go#L398: func unsafe_New(*abi.Type) unsafe.Pointer
		value.go#L412: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
		value.go#L459: func ifaceE2I(t *abi.Type, src any, dst unsafe.Pointer)
		value.go#L464: func typedmemmove(t *abi.Type, dst, src unsafe.Pointer)

	reflect
		abi.go#L124: func (a *abiSeq) addArg(t *abi.Type) *abiStep {
		abi.go#L165: func (a *abiSeq) addRcvr(rcvr *abi.Type) (*abiStep, bool) {
		abi.go#L198: func (a *abiSeq) regAssign(t *abi.Type, offset uintptr) bool {
		abi.go#L387: func newAbiDesc(t *funcType, rcvr *abi.Type) abiDesc {
		badlinkname.go#L29: func unusedIfaceIndir(t *abi.Type) bool {
		badlinkname.go#L127: func badlinkname_rtype_ptrTo(*rtype) *abi.Type
		type.go#L250: 	common() *abi.Type
		type.go#L313: 	abi.Type
		type.go#L319: 	t abi.Type
		type.go#L322: func (t *rtype) common() *abi.Type {
		type.go#L371: func nameOffFor(t *abi.Type, off aNameOff) abi.Name {
		type.go#L375: func typeOffFor(t *abi.Type, off aTypeOff) *abi.Type {
		type.go#L379: func (t *interfaceType) typeOff(off aTypeOff) *abi.Type {
		type.go#L383: func (t *interfaceType) common() *abi.Type {
		type.go#L546: func resolveReflectType(t *abi.Type) aTypeOff {
		type.go#L561: func (t *rtype) typeOff(off aTypeOff) *abi.Type {
		type.go#L562: 	return (*abi.Type)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
		type.go#L569: func textOffFor(t *abi.Type, off aTextOff) unsafe.Pointer {
		type.go#L693: func pkgPathFor(t *abi.Type) string {
		type.go#L716: func nameFor(t *abi.Type) string {
		type.go#L728: func toRType(t *abi.Type) *rtype {
		type.go#L732: func elem(t *abi.Type) *abi.Type {
		type.go#L896: func canRangeFunc(t *abi.Type) bool {
		type.go#L924: func canRangeFunc2(t *abi.Type) bool {
		type.go#L1217: 				var ntyp *abi.Type
		type.go#L1301: func rtypeOf(i any) *abi.Type {
		type.go#L1323: func (t *rtype) ptrTo() *abi.Type {
		type.go#L1367: func ptrTo(t *abi.Type) *abi.Type {
		type.go#L1409: func implements(T, V *abi.Type) bool {
		type.go#L1497: func specialChannelAssignability(T, V *abi.Type) bool {
		type.go#L1510: func directlyAssignable(T, V *abi.Type) bool {
		type.go#L1530: func haveIdenticalType(T, V *abi.Type, cmpTags bool) bool {
		type.go#L1542: func haveIdenticalUnderlyingType(T, V *abi.Type, cmpTags bool) bool {
		type.go#L1664: func rtypeOff(section unsafe.Pointer, off int32) *abi.Type {
		type.go#L1665: 	return (*abi.Type)(add(section, uintptr(off), "sizeof(rtype) > 0"))
		type.go#L1683: func typesByString(s string) []*abi.Type {
		type.go#L1685: 	var ret []*abi.Type
		type.go#L1726: 	t1    *abi.Type
		type.go#L1727: 	t2    *abi.Type
		type.go#L1958: 		for _, t := range ts.([]*abi.Type) {
		type.go#L1969: 		for _, t := range ts.([]*abi.Type) {
		type.go#L1976: 	addToCache := func(tt *abi.Type) Type {
		type.go#L1977: 		var rts []*abi.Type
		type.go#L1979: 			rts = rti.([]*abi.Type)
		type.go#L1998: func stringFor(t *abi.Type) string {
		type.go#L2038: func isReflexive(t *abi.Type) bool {
		type.go#L2062: func needKeyUpdate(t *abi.Type) bool {
		type.go#L2089: func hashMightPanic(t *abi.Type) bool {
		type.go#L2109: func bucketOf(ktyp, etyp *abi.Type) *abi.Type {
		type.go#L2160: 	b := &abi.Type{
		type.go#L2178: func emitGCMask(out []byte, base uintptr, typ *abi.Type, n uintptr) {
		type.go#L2197: func appendGCProg(dst []byte, typ *abi.Type) []byte {
		type.go#L2754: func typeptrdata(t *abi.Type) uintptr {
		type.go#L2943: func toType(t *abi.Type) Type {
		type.go#L2952: 	rcvr *abi.Type // receiver type, or nil if none
		type.go#L2956: 	t         *abi.Type
		type.go#L2970: func funcLayout(t *funcType, rcvr *abi.Type) (frametype *abi.Type, framePool *sync.Pool, abid abiDesc) {
		type.go#L2987: 	x := &abi.Type{
		type.go#L3041: func addTypeBits(bv *bitVector, offset uintptr, t *abi.Type) {
		value.go#L42: 	typ_ *abi.Type
		value.go#L99: func (v Value) typ() *abi.Type {
		value.go#L105: 	return (*abi.Type)(abi.NoEscape(unsafe.Pointer(v.typ_)))
		value.go#L394: 		rcvrtype *abi.Type
		value.go#L875: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *abi.Type, t *funcType, fn unsafe.Pointer) {
		value.go#L2046: func copyVal(typ *abi.Type, fl flag, ptr unsafe.Pointer) Value {
		value.go#L2693: func (v Value) abiType() *abi.Type {
		value.go#L2700: func (v Value) abiTypeSlow() *abi.Type {
		value.go#L3198: func unsafe_New(*abi.Type) unsafe.Pointer
		value.go#L3201: func unsafe_NewArray(*abi.Type, int) unsafe.Pointer
		value.go#L3340: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
		value.go#L3527: func convertOp(dst, src *abi.Type) func(Value, Type) Value {
		value.go#L3879: func makechan(typ *abi.Type, size int) (ch unsafe.Pointer)
		value.go#L3880: func makemap(t *abi.Type, cap int) (m unsafe.Pointer)
		value.go#L3883: func mapaccess(t *abi.Type, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
		value.go#L3886: func mapaccess_faststr(t *abi.Type, m unsafe.Pointer, key string) (val unsafe.Pointer)
		value.go#L3889: func mapassign0(t *abi.Type, m unsafe.Pointer, key, val unsafe.Pointer)
		value.go#L3901: func mapassign(t *abi.Type, m unsafe.Pointer, key, val unsafe.Pointer) {
		value.go#L3908: func mapassign_faststr0(t *abi.Type, m unsafe.Pointer, key string, val unsafe.Pointer)
		value.go#L3910: func mapassign_faststr(t *abi.Type, m unsafe.Pointer, key string, val unsafe.Pointer) {
		value.go#L3917: func mapdelete(t *abi.Type, m unsafe.Pointer, key unsafe.Pointer)
		value.go#L3920: func mapdelete_faststr(t *abi.Type, m unsafe.Pointer, key string)
		value.go#L3923: func mapiterinit(t *abi.Type, m unsafe.Pointer, it *hiter)
		value.go#L3937: func mapclear(t *abi.Type, m unsafe.Pointer)
		value.go#L3965: func call(stackArgsType *abi.Type, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs)
		value.go#L3967: func ifaceE2I(t *abi.Type, src any, dst unsafe.Pointer)
		value.go#L3977: func typedmemmove(t *abi.Type, dst, src unsafe.Pointer)
		value.go#L3982: func typedmemclr(t *abi.Type, ptr unsafe.Pointer)
		value.go#L3988: func typedmemclrpartial(t *abi.Type, ptr unsafe.Pointer, off, size uintptr)
		value.go#L3994: func typedslicecopy(t *abi.Type, dst, src unsafeheader.Slice) int
		value.go#L4000: func typedarrayclear(elemType *abi.Type, ptr unsafe.Pointer, len int)
		value.go#L4003: func typehash(t *abi.Type, p unsafe.Pointer, h uintptr) uintptr
		value.go#L4008: func growslice(t *abi.Type, old unsafeheader.Slice, num int) unsafeheader.Slice
		value.go#L4011: func unsafeslice(t *abi.Type, ptr unsafe.Pointer, len int)

	runtime
		mbarrier.go#L162: func typedmemmove(typ *abi.Type, dst, src unsafe.Pointer) {
		mbitmap.go#L214: func (span *mspan) typePointersOfType(typ *abi.Type, addr uintptr) typePointers {
		mbitmap.go#L418: func bulkBarrierPreWrite(dst, src, size uintptr, typ *abi.Type) {
		mbitmap.go#L504: func bulkBarrierPreWriteSrcOnly(dst, src, size uintptr, typ *abi.Type) {
		traceallocfree.go#L113: func (tl traceLocker) HeapObjectExists(addr uintptr, typ *abi.Type) {
		traceallocfree.go#L120: func (tl traceLocker) HeapObjectAlloc(addr uintptr, typ *abi.Type) {
		traceevent.go#L207: func (tl traceLocker) rtype(typ *abi.Type) traceArg {
		tracetype.go#L25: func (t *traceTypeTable) put(typ *abi.Type) uint64 {
		tracetype.go#L47: 	typ := (*abi.Type)(*(*unsafe.Pointer)(unsafe.Pointer(&node.data[0])))
		type.go#L18: type _type = abi.Type
		type.go#L22: 	*abi.Type // embedding is okay here (unlike reflect) because none of this is public
		type.go#L329: func toRType(t *abi.Type) rtype {

	unique
		clone.go#L38: func makeCloneSeq(typ *abi.Type) cloneSeq {
		clone.go#L56: func buildStructCloneSeq(typ *abi.Type, seq *cloneSeq, baseOffset uintptr) {
		clone.go#L72: func buildArrayCloneSeq(typ *abi.Type, seq *cloneSeq, baseOffset uintptr) {
		handle.go#L94: 	uniqueMaps = concurrent.NewHashTrieMap[*abi.Type, any]() // any is always a *uniqueMap[T].
		handle.go#L114: func addUniqueMap[T comparable](typ *abi.Type) *uniqueMap[T] {