type reflect.rtype

162 uses

	reflect (current package)
		makefunc.go#L106: 	ftyp := (*funcType)(unsafe.Pointer(v.Type().(*rtype)))
		swapper.go#L33: 	typ := v.Type().Elem().(*rtype)
		type.go#L212: 	common() *rtype
		type.go#L305: type rtype struct {
		type.go#L352: 	rtype
		type.go#L353: 	elem  *rtype // array element type
		type.go#L354: 	slice *rtype // slice type
		type.go#L360: 	rtype
		type.go#L361: 	elem *rtype  // channel element type
		type.go#L377: 	rtype
		type.go#L390: 	rtype
		type.go#L397: 	rtype
		type.go#L398: 	key    *rtype // map key type
		type.go#L399: 	elem   *rtype // map element (value) type
		type.go#L400: 	bucket *rtype // internal bucket structure
		type.go#L411: 	rtype
		type.go#L412: 	elem *rtype // pointer element (pointed at) type
		type.go#L417: 	rtype
		type.go#L418: 	elem *rtype // slice element type
		type.go#L424: 	typ         *rtype  // type of field
		type.go#L438: 	rtype
		type.go#L670: func resolveReflectType(t *rtype) typeOff {
		type.go#L685: func (t *rtype) nameOff(off nameOff) name {
		type.go#L689: func (t *rtype) typeOff(off typeOff) *rtype {
		type.go#L690: 	return (*rtype)(resolveTypeOff(unsafe.Pointer(t), int32(off)))
		type.go#L693: func (t *rtype) textOff(off textOff) unsafe.Pointer {
		type.go#L697: func (t *rtype) uncommon() *uncommonType {
		type.go#L748: 			rtype
		type.go#L755: func (t *rtype) String() string {
		type.go#L763: func (t *rtype) Size() uintptr { return t.size }
		type.go#L765: func (t *rtype) Bits() int {
		type.go#L776: func (t *rtype) Align() int { return int(t.align) }
		type.go#L778: func (t *rtype) FieldAlign() int { return int(t.fieldAlign) }
		type.go#L780: func (t *rtype) Kind() Kind { return Kind(t.kind & kindMask) }
		type.go#L782: func (t *rtype) pointers() bool { return t.ptrdata != 0 }
		type.go#L784: func (t *rtype) common() *rtype { return t }
		type.go#L786: func (t *rtype) exportedMethods() []method {
		type.go#L794: func (t *rtype) NumMethod() int {
		type.go#L802: func (t *rtype) Method(i int) (m Method) {
		type.go#L830: 	m.Func = Value{mt.(*rtype), fn, fl}
		type.go#L836: func (t *rtype) MethodByName(name string) (m Method, ok bool) {
		type.go#L854: func (t *rtype) PkgPath() string {
		type.go#L865: func (t *rtype) hasName() bool {
		type.go#L869: func (t *rtype) Name() string {
		type.go#L881: func (t *rtype) ChanDir() ChanDir {
		type.go#L889: func (t *rtype) IsVariadic() bool {
		type.go#L897: func (t *rtype) Elem() Type {
		type.go#L918: func (t *rtype) Field(i int) StructField {
		type.go#L926: func (t *rtype) FieldByIndex(index []int) StructField {
		type.go#L934: func (t *rtype) FieldByName(name string) (StructField, bool) {
		type.go#L942: func (t *rtype) FieldByNameFunc(match func(string) bool) (StructField, bool) {
		type.go#L950: func (t *rtype) In(i int) Type {
		type.go#L958: func (t *rtype) Key() Type {
		type.go#L966: func (t *rtype) Len() int {
		type.go#L974: func (t *rtype) NumField() int {
		type.go#L982: func (t *rtype) NumIn() int {
		type.go#L990: func (t *rtype) NumOut() int {
		type.go#L998: func (t *rtype) Out(i int) Type {
		type.go#L1006: func (t *funcType) in() []*rtype {
		type.go#L1014: 	return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.inCount:t.inCount]
		type.go#L1017: func (t *funcType) out() []*rtype {
		type.go#L1026: 	return (*[1 << 20]*rtype)(add(unsafe.Pointer(t), uadd, "outCount > 0"))[t.inCount : t.inCount+outCount : t.inCount+outCount]
		type.go#L1289: 				var ntyp *rtype
		type.go#L1379: 	return t.(*rtype).ptrTo()
		type.go#L1382: func (t *rtype) ptrTo() *rtype {
		type.go#L1433: func (t *rtype) Implements(u Type) bool {
		type.go#L1440: 	return implements(u.(*rtype), t)
		type.go#L1443: func (t *rtype) AssignableTo(u Type) bool {
		type.go#L1447: 	uu := u.(*rtype)
		type.go#L1451: func (t *rtype) ConvertibleTo(u Type) bool {
		type.go#L1455: 	uu := u.(*rtype)
		type.go#L1459: func (t *rtype) Comparable() bool {
		type.go#L1464: func implements(T, V *rtype) bool {
		type.go#L1552: func specialChannelAssignability(T, V *rtype) bool {
		type.go#L1565: func directlyAssignable(T, V *rtype) bool {
		type.go#L1597: func haveIdenticalUnderlyingType(T, V *rtype, cmpTags bool) bool {
		type.go#L1707: func rtypeOff(section unsafe.Pointer, off int32) *rtype {
		type.go#L1708: 	return (*rtype)(add(section, uintptr(off), "sizeof(rtype) > 0"))
		type.go#L1715: func typesByString(s string) []*rtype {
		type.go#L1717: 	var ret []*rtype
		type.go#L1758: 	t1    *rtype
		type.go#L1759: 	t2    *rtype
		type.go#L1780: 	typ := t.(*rtype)
		type.go#L1785: 		return ch.(*rtype)
		type.go#L1843: 	ktyp := key.(*rtype)
		type.go#L1844: 	etyp := elem.(*rtype)
		type.go#L1913: 	args [4]*rtype
		type.go#L1917: 	args [8]*rtype
		type.go#L1921: 	args [16]*rtype
		type.go#L1925: 	args [32]*rtype
		type.go#L1929: 	args [64]*rtype
		type.go#L1933: 	args [128]*rtype
		type.go#L1954: 	var args []*rtype
		type.go#L1988: 		t := in.(*rtype)
		type.go#L1997: 		t := out.(*rtype)
		type.go#L2014: 		for _, t := range ts.([]*rtype) {
		type.go#L2025: 		for _, t := range ts.([]*rtype) {
		type.go#L2032: 	addToCache := func(tt *rtype) Type {
		type.go#L2033: 		var rts []*rtype
		type.go#L2035: 			rts = rti.([]*rtype)
		type.go#L2091: func isReflexive(t *rtype) bool {
		type.go#L2115: func needKeyUpdate(t *rtype) bool {
		type.go#L2142: func hashMightPanic(t *rtype) bool {
		type.go#L2172: func bucketOf(ktyp, etyp *rtype) *rtype {
		type.go#L2174: 		ktyp = PtrTo(ktyp).(*rtype)
		type.go#L2177: 		etyp = PtrTo(etyp).(*rtype)
		type.go#L2221: 	b := &rtype{
		type.go#L2236: func (t *rtype) gcSlice(begin, end uintptr) []byte {
		type.go#L2242: func emitGCMask(out []byte, base uintptr, typ *rtype, n uintptr) {
		type.go#L2261: func appendGCProg(dst []byte, typ *rtype) []byte {
		type.go#L2288: 	typ := t.(*rtype)
		type.go#L2801: func typeptrdata(t *rtype) uintptr {
		type.go#L2833: 	typ := elem.(*rtype)
		type.go#L2877: 	array.slice = SliceOf(elem).(*rtype)
		type.go#L2973: func toType(t *rtype) Type {
		type.go#L2982: 	rcvr *rtype    // receiver type, or nil if none
		type.go#L2986: 	t         *rtype
		type.go#L3001: func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, argSize, retOffset uintptr, stk *bitVector, framePool *sync.Pool) {
		type.go#L3044: 	x := &rtype{
		type.go#L3077: func ifaceIndir(t *rtype) bool {
		type.go#L3096: func addTypeBits(bv *bitVector, offset uintptr, t *rtype) {
		value.go#L39: 	typ *rtype
		value.go#L195: 	typ  *rtype
		value.go#L203: 		ityp *rtype // static interface type
		value.go#L204: 		typ  *rtype // dynamic concrete type
		value.go#L361: 		rcvrtype *rtype
		value.go#L454: 		targ := t.In(i).(*rtype)
		value.go#L635: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer) {
		value.go#L934: var uint8Type = TypeOf(uint8(0)).(*rtype)
		value.go#L1305: func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value {
		value.go#L2128: 	typ *rtype         // channel type
		value.go#L2284: func unsafe_New(*rtype) unsafe.Pointer
		value.go#L2285: func unsafe_NewArray(*rtype, int) unsafe.Pointer
		value.go#L2303: 	s := unsafeheader.Slice{Data: unsafe_NewArray(typ.Elem().(*rtype), cap), Len: len, Cap: cap}
		value.go#L2304: 	return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
		value.go#L2318: 	t := typ.(*rtype)
		value.go#L2334: 	t := typ.(*rtype)
		value.go#L2374: 	t := typ.(*rtype)
		value.go#L2400: 	t := typ.(*rtype)
		value.go#L2410: 	t := typ.(*rtype)
		value.go#L2418: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
		value.go#L2470: func convertOp(dst, src *rtype) func(Value, Type) Value {
		value.go#L2742: 		ifaceE2I(typ.(*rtype), x, target)
		value.go#L2776: func makechan(typ *rtype, size int) (ch unsafe.Pointer)
		value.go#L2777: func makemap(t *rtype, cap int) (m unsafe.Pointer)
		value.go#L2780: func mapaccess(t *rtype, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
		value.go#L2783: func mapassign(t *rtype, m unsafe.Pointer, key, val unsafe.Pointer)
		value.go#L2786: func mapdelete(t *rtype, m unsafe.Pointer, key unsafe.Pointer)
		value.go#L2791: func mapiterinit(t *rtype, m unsafe.Pointer) unsafe.Pointer
		value.go#L2812: func call(argtype *rtype, fn, arg unsafe.Pointer, n uint32, retoffset uint32)
		value.go#L2814: func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer)
		value.go#L2822: func typedmemmove(t *rtype, dst, src unsafe.Pointer)
		value.go#L2827: func typedmemmovepartial(t *rtype, dst, src unsafe.Pointer, off, size uintptr)
		value.go#L2831: func typedmemclr(t *rtype, ptr unsafe.Pointer)
		value.go#L2836: func typedmemclrpartial(t *rtype, ptr unsafe.Pointer, off, size uintptr)
		value.go#L2841: func typedslicecopy(elemType *rtype, dst, src unsafeheader.Slice) int
		value.go#L2844: func typehash(t *rtype, p unsafe.Pointer, h uintptr) uintptr