type go/types.TypeParam
94 uses
go/types (current package)
builtins.go#L828: if tp, _ := x.typ.(*TypeParam); tp != nil {
check.go#L126: recvTParamMap map[*ast.Ident]*TypeParam // maps blank receiver type parameters to their type
conversions.go#L50: ok = T.(*TypeParam).underIs(func(u Type) bool {
conversions.go#L140: Vp, _ := V.(*TypeParam)
conversions.go#L141: Tp, _ := T.(*TypeParam)
decl.go#L600: var tparams []*TypeParam
decl.go#L674: func (check *Checker) declareTypeParams(tparams []*TypeParam, names []*ast.Ident) []*TypeParam {
errors.go#L113: case []*TypeParam:
expr.go#L150: if tpar, _ := typ.(*TypeParam); tpar != nil {
infer.go#L32: func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (result []Type) {
infer.go#L104: tparams2 := make([]*TypeParam, len(tparams))
infer.go#L262: } else if _, ok := par.typ.(*TypeParam); ok {
infer.go#L294: tpar := params.At(i).typ.(*TypeParam) // is type parameter by construction of indices
infer.go#L332: func typeParamsString(list []*TypeParam) string {
infer.go#L358: func isParameterized(tparams []*TypeParam, typ Type) bool {
infer.go#L368: tparams []*TypeParam
infer.go#L439: case *TypeParam:
infer.go#L467: func (check *Checker) inferB(posn positioner, tparams []*TypeParam, targs []Type) (types []Type, index int) {
infer.go#L664: func coreTerm(tpar *TypeParam) (*term, bool) {
infer.go#L697: tparams []*TypeParam
infer.go#L707: if tpar, _ := typ.(*TypeParam); tpar != nil {
infer.go#L773: case *TypeParam:
instantiate.go#L44: var tparams []*TypeParam
instantiate.go#L136: func (check *Checker) verify(pos token.Pos, tparams []*TypeParam, targs []Type) (int, error) {
mono.go#L57: canon map[*TypeParam]*TypeParam
mono.go#L153: case *TypeParam:
mono.go#L161: func (w *monoGraph) recordCanon(mpar, tpar *TypeParam) {
mono.go#L163: w.canon = make(map[*TypeParam]*TypeParam)
mono.go#L170: func (w *monoGraph) recordInstance(pkg *Package, pos token.Pos, tparams []*TypeParam, targs []Type, xlist []ast.Expr) {
mono.go#L181: func (w *monoGraph) assign(pkg *Package, pos token.Pos, tpar *TypeParam, targ Type) {
mono.go#L212: case *TypeParam:
mono.go#L285: if tpar, ok := elem.Type().(*TypeParam); ok {
mono.go#L305: func (w *monoGraph) typeParamVertex(tpar *TypeParam) int {
named.go#L119: func (t *Named) SetTypeParams(tparams []*TypeParam) {
object.go#L235: func _NewTypeNameLazy(pos token.Pos, pkg *Package, name string, load func(named *Named) (tparams []*TypeParam, underlying Type, methods []*Func)) *TypeName {
object.go#L272: case *TypeParam:
object.go#L476: } else if t, _ := typ.(*TypeParam); t != nil {
operand.go#L173: if tpar, _ := x.typ.(*TypeParam); tpar != nil {
operand.go#L248: Vp, _ := V.(*TypeParam)
operand.go#L249: Tp, _ := T.(*TypeParam)
predicates.go#L52: if tpar, _ := t.(*TypeParam); tpar != nil {
predicates.go#L63: case *Basic, *Named, *TypeParam:
predicates.go#L92: _, ok := t.(*TypeParam)
predicates.go#L418: case *TypeParam:
signature.go#L46: func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature {
signature.go#L127: check.recvTParamMap = make(map[*ast.Ident]*TypeParam)
signature.go#L134: var recvTParams []*TypeParam
sizes.go#L79: case *TypeParam, *Union:
sizes.go#L161: case *TypeParam, *Union:
subst.go#L11: type substMap map[*TypeParam]Type
subst.go#L15: func makeSubstMap(tpars []*TypeParam, targs []Type) substMap {
subst.go#L26: func makeRenameMap(from, to []*TypeParam) substMap {
subst.go#L39: func (m substMap) lookup(tpar *TypeParam) Type {
subst.go#L61: case *TypeParam:
subst.go#L270: case *TypeParam:
type.go#L35: tpar, _ := t.(*TypeParam)
type.go#L64: tpar, _ := t.(*TypeParam)
typelists.go#L8: type TypeParamList struct{ tparams []*TypeParam }
typelists.go#L15: func (l *TypeParamList) At(i int) *TypeParam { return l.tparams[i] }
typelists.go#L20: func (l *TypeParamList) list() []*TypeParam {
typelists.go#L58: func bindTParams(list []*TypeParam) *TypeParamList {
typeparam.go#L21: type TypeParam struct {
typeparam.go#L35: func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
typeparam.go#L40: func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
typeparam.go#L47: typ := &TypeParam{check: check, id: id, obj: obj, index: -1, bound: constraint}
typeparam.go#L63: func (t *TypeParam) Index() int {
typeparam.go#L68: func (t *TypeParam) Obj() *TypeName { return t.obj }
typeparam.go#L71: func (t *TypeParam) Constraint() Type {
typeparam.go#L81: func (t *TypeParam) SetConstraint(bound Type) {
typeparam.go#L91: func (t *TypeParam) Underlying() Type {
typeparam.go#L95: func (t *TypeParam) String() string { return TypeString(t, nil) }
typeparam.go#L100: func (t *TypeParam) cleanup() {
typeparam.go#L106: func (t *TypeParam) iface() *Interface {
typeparam.go#L149: func (t *TypeParam) is(f func(*term) bool) bool {
typeparam.go#L156: func (t *TypeParam) underIs(f func(Type) bool) bool {
typestring.go#L297: case *TypeParam:
typestring.go#L368: func (w *typeWriter) tParamList(list []*TypeParam) {
unify.go#L95: tparams []*TypeParam
unify.go#L126: func (d *tparamsList) init(tparams []*TypeParam) {
unify.go#L188: if tpar, ok := typ.(*TypeParam); ok {
unify.go#L196: func tparamIndex(list []*TypeParam, tpar *TypeParam) int {
unify.go#L568: case *TypeParam:
validtype.go#L94: case *TypeParam:
golang.org/x/exp/apidiff
correspondence.go#L129: case *types.TypeParam:
correspondence.go#L130: if new, ok := new.(*types.TypeParam); ok {
golang.org/x/tools/internal/gcimporter
ureader_yes.go#L146: tparams []*types.TypeParam
ureader_yes.go#L448: func (r *reader) signature(recv *types.Var, rtparams, tparams []*types.TypeParam) *types.Signature {
ureader_yes.go#L655: func (r *reader) typeParamNames() []*types.TypeParam {
ureader_yes.go#L672: r.dict.tparams = make([]*types.TypeParam, len(r.dict.bounds))
golang.org/x/tools/internal/typeparams
typeparams_go118.go#L35: type TypeParam = types.TypeParam