type go/types.TypeParam
145 uses
go/types (current package)
alias.go#L87: func (a *Alias) SetTypeParams(tparams []*TypeParam) {
badlinkname.go#L20: func badlinkname_Checker_infer(*Checker, positioner, []*TypeParam, []Type, *Tuple, []*operand, bool, *error_) []Type
builtins.go#L966: if tp, _ := Unalias(x.typ).(*TypeParam); tp != nil {
call.go#L543: var tparams []*TypeParam
conversions.go#L150: Vp, _ := V.(*TypeParam)
conversions.go#L151: Tp, _ := T.(*TypeParam)
decl.go#L657: var tparams []*TypeParam
decl.go#L734: func (check *Checker) declareTypeParam(name *ast.Ident, scopePos token.Pos) *TypeParam {
format.go#L60: case []*TypeParam:
gcsizes.go#L61: case *TypeParam, *Union:
gcsizes.go#L159: case *TypeParam, *Union:
infer.go#L35: func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand, reverse bool, err *error_) (inferred []Type) {
infer.go#L184: } else if _, ok := par.typ.(*TypeParam); ok && !arg.isNil() {
infer.go#L333: var maxUntyped map[*TypeParam]Type // lazily allocated (we may not need it)
infer.go#L335: tpar := params.At(index).typ.(*TypeParam) // is type parameter (no alias) by construction of untyped
infer.go#L339: maxUntyped = make(map[*TypeParam]Type)
infer.go#L471: func (check *Checker) renameTParams(pos token.Pos, tparams []*TypeParam, typ Type) ([]*TypeParam, Type) {
infer.go#L503: tparams2 := make([]*TypeParam, len(tparams))
infer.go#L520: func typeParamsString(list []*TypeParam) string {
infer.go#L548: func isParameterized(tparams []*TypeParam, typ Type) bool {
infer.go#L557: tparams []*TypeParam
infer.go#L632: case *TypeParam:
infer.go#L655: func coreTerm(tpar *TypeParam) (*term, bool) {
infer.go#L694: func killCycles(tparams []*TypeParam, inferred []Type) {
infer.go#L702: tparams []*TypeParam
infer.go#L713: if tpar, _ := typ.(*TypeParam); tpar != nil {
infer.go#L782: case *TypeParam:
instantiate.go#L212: func (check *Checker) verify(pos token.Pos, tparams []*TypeParam, targs []Type, ctxt *Context) (int, error) {
iter.go#L138: func (l *TypeParamList) TypeParams() iter.Seq[*TypeParam] {
iter.go#L139: return func(yield func(tparam *TypeParam) bool) {
mono.go#L61: canon map[*TypeParam]*TypeParam
mono.go#L158: case *TypeParam:
mono.go#L167: func (w *monoGraph) recordCanon(mpar, tpar *TypeParam) {
mono.go#L169: w.canon = make(map[*TypeParam]*TypeParam)
mono.go#L176: func (w *monoGraph) recordInstance(pkg *Package, pos token.Pos, tparams []*TypeParam, targs []Type, xlist []ast.Expr) {
mono.go#L187: func (w *monoGraph) assign(pkg *Package, pos token.Pos, tpar *TypeParam, targ Type) {
mono.go#L218: case *TypeParam:
mono.go#L291: if tpar, ok := elem.Type().(*TypeParam); ok {
mono.go#L311: func (w *monoGraph) typeParamVertex(tpar *TypeParam) int {
named.go#L134: loader func(*Named) (tparams []*TypeParam, underlying Type, methods []*Func)
named.go#L329: func (t *Named) SetTypeParams(tparams []*TypeParam) {
object.go#L299: func _NewTypeNameLazy(pos token.Pos, pkg *Package, name string, load func(named *Named) (tparams []*TypeParam, underlying Type, methods []*Func)) *TypeName {
object.go#L326: case *TypeParam:
object.go#L589: } else if t, _ := typ.(*TypeParam); t != nil {
operand.go#L194: tpar, _ := Unalias(x.typ).(*TypeParam)
operand.go#L328: Vp, _ := V.(*TypeParam)
operand.go#L329: Tp, _ := T.(*TypeParam)
predicates.go#L61: if tpar, _ := Unalias(t).(*TypeParam); tpar != nil {
predicates.go#L72: case *Basic, *Named, *TypeParam:
predicates.go#L83: case *Named, *TypeParam:
predicates.go#L127: _, ok := Unalias(t).(*TypeParam)
predicates.go#L136: if tpar, _ := Unalias(t).(*TypeParam); tpar != nil && tpar.bound != nil {
predicates.go#L492: case *TypeParam:
signature.go#L51: func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature {
signature.go#L227: recvTParams := make([]*TypeParam, len(rtparams))
signature.go#L450: case *TypeParam:
sizes.go#L99: case *TypeParam, *Union:
sizes.go#L226: case *TypeParam, *Union:
subst.go#L16: type substMap map[*TypeParam]Type
subst.go#L20: func makeSubstMap(tpars []*TypeParam, targs []Type) substMap {
subst.go#L31: func makeRenameMap(from, to []*TypeParam) substMap {
subst.go#L44: func (m substMap) lookup(tpar *TypeParam) Type {
subst.go#L69: case *TypeParam:
subst.go#L269: case *TypeParam:
typelists.go#L11: type TypeParamList struct{ tparams []*TypeParam }
typelists.go#L18: func (l *TypeParamList) At(i int) *TypeParam { return l.tparams[i] }
typelists.go#L23: func (l *TypeParamList) list() []*TypeParam {
typelists.go#L61: func bindTParams(list []*TypeParam) *TypeParamList {
typeparam.go#L25: type TypeParam struct {
typeparam.go#L39: func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
typeparam.go#L44: func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
typeparam.go#L51: typ := &TypeParam{check: check, id: id, obj: obj, index: -1, bound: constraint}
typeparam.go#L66: func (t *TypeParam) Obj() *TypeName { return t.obj }
typeparam.go#L70: func (t *TypeParam) Index() int {
typeparam.go#L75: func (t *TypeParam) Constraint() Type {
typeparam.go#L85: func (t *TypeParam) SetConstraint(bound Type) {
typeparam.go#L99: func (t *TypeParam) Underlying() Type {
typeparam.go#L103: func (t *TypeParam) String() string { return TypeString(t, nil) }
typeparam.go#L108: func (t *TypeParam) cleanup() {
typeparam.go#L114: func (t *TypeParam) iface() *Interface {
typeparam.go#L157: func (t *TypeParam) is(f func(*term) bool) bool {
typeparam.go#L165: func (t *TypeParam) typeset(yield func(t, u Type) bool) {
typestring.go#L309: case *TypeParam:
typestring.go#L407: func (w *typeWriter) tParamList(list []*TypeParam) {
under.go#L39: if p, _ := Unalias(t).(*TypeParam); p != nil {
unify.go#L82: handles map[*TypeParam]*Type
unify.go#L91: func newUnifier(tparams []*TypeParam, targs []Type, enableInterfaceInference bool) *unifier {
unify.go#L93: handles := make(map[*TypeParam]*Type, len(tparams))
unify.go#L178: type typeParamsById []*TypeParam
unify.go#L187: func (u *unifier) join(x, y *TypeParam) bool {
unify.go#L213: func (u *unifier) asBoundTypeParam(x Type) *TypeParam {
unify.go#L214: if x, _ := Unalias(x).(*TypeParam); x != nil {
unify.go#L224: func (u *unifier) setHandle(x *TypeParam, h *Type) {
unify.go#L235: func (u *unifier) at(x *TypeParam) Type {
unify.go#L241: func (u *unifier) set(x *TypeParam, t Type) {
unify.go#L264: func (u *unifier) inferred(tparams []*TypeParam) []Type {
unify.go#L275: if _, ok := Unalias(x).(*TypeParam); !ok {
unify.go#L755: case *TypeParam:
validtype.go#L160: 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/go/types/objectpath
objectpath.go#L231: if _, ok := types.Unalias(obj.Type()).(*types.TypeParam); !ok {
objectpath.go#L543: case *types.TypeParam:
objectpath.go#L728: tparam, ok := t.(*types.TypeParam)
golang.org/x/tools/go/types/typeutil
map.go#L314: case *types.TypeParam:
map.go#L359: func (h hasher) hashTypeParam(t *types.TypeParam) uint32 {
map.go#L471: case *types.TypeParam:
golang.org/x/tools/internal/aliases
aliases.go#L28: func NewAlias(enabled bool, pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
aliases_go122.go#L34: func SetTypeParams(alias *types.Alias, tparams []*types.TypeParam) {
aliases_go122.go#L36: SetTypeParams(tparams []*types.TypeParam)
golang.org/x/tools/internal/gcimporter
iexport.go#L755: if tparam, ok := types.Unalias(t).(*types.TypeParam); ok {
iexport.go#L1029: case *types.TypeParam:
iexport.go#L1250: func tparamExportName(prefix string, tparam *types.TypeParam) string {
iimport.go#L365: t *types.TypeParam
iimport.go#L574: var tparams []*types.TypeParam
iimport.go#L589: var tparams []*types.TypeParam
iimport.go#L626: var rparams []*types.TypeParam
iimport.go#L628: rparams = make([]*types.TypeParam, targs.Len())
iimport.go#L630: rparams[i] = types.Unalias(targs.At(i)).(*types.TypeParam)
iimport.go#L1052: func (r *importReader) signature(recv *types.Var, rparams []*types.TypeParam, tparams []*types.TypeParam) *types.Signature {
iimport.go#L1059: func (r *importReader) tparamList() []*types.TypeParam {
iimport.go#L1064: xs := make([]*types.TypeParam, n)
iimport.go#L1068: xs[i] = types.Unalias(r.typ()).(*types.TypeParam)
ureader_yes.go#L168: tparams []*types.TypeParam
ureader_yes.go#L445: func (r *reader) signature(recv *types.Var, rtparams, tparams []*types.TypeParam) *types.Signature {
ureader_yes.go#L537: var tparams []*types.TypeParam
ureader_yes.go#L664: func (r *reader) typeParamNames() []*types.TypeParam {
ureader_yes.go#L681: r.dict.tparams = make([]*types.TypeParam, len(r.dict.bounds))
golang.org/x/tools/internal/typeparams
common.go#L66: _, ok := types.Unalias(t).(*types.TypeParam)
coretype.go#L119: case *types.TypeParam:
free.go#L123: case *types.TypeParam:
normalize.go#L63: func StructuralTerms(tparam *types.TypeParam) ([]*types.Term, error) {
normalize.go#L165: if _, ok := embedded.Underlying().(*types.TypeParam); ok {
normalize.go#L187: case *types.TypeParam, *types.Union:
normalize.go#L202: case *types.TypeParam:
golang.org/x/tools/internal/typesinternal
element.go#L124: case *types.TypeParam, *types.Union:
types.go#L89: case *types.TypeParam:
types.go#L118: SetTypeParams(tparams []*types.TypeParam)
zerovalue.go#L87: case *types.TypeParam:
zerovalue.go#L181: case *types.TypeParam:
zerovalue.go#L301: case *types.TypeParam: