type go/types.TypeParam
212 uses
go/types (current package)
alias.go#L86: func (a *Alias) SetTypeParams(tparams []*TypeParam) {
badlinkname.go#L20: func badlinkname_Checker_infer(*Checker, positioner, []*TypeParam, []Type, *Tuple, []*operand, bool, *error_) []Type
builtins.go#L1055: 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#L574: if tpar, ok := rhs.(*TypeParam); ok && alias.tparams != nil && slices.Index(alias.tparams.list(), tpar) >= 0 {
decl.go#L636: var tparams []*TypeParam
decl.go#L713: func (check *Checker) declareTypeParam(name *ast.Ident, scopePos token.Pos) *TypeParam {
format.go#L71: 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#L695: func killCycles(tparams []*TypeParam, inferred []Type) {
infer.go#L703: tparams []*TypeParam
infer.go#L714: if tpar, _ := typ.(*TypeParam); tpar != nil {
infer.go#L783: case *TypeParam:
instantiate.go#L207: 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#L133: loader func(*Named) ([]*TypeParam, Type, []*Func, []func())
named.go#L397: func (t *Named) SetTypeParams(tparams []*TypeParam) {
object.go#L259: func _NewTypeNameLazy(pos token.Pos, pkg *Package, name string, load func(*Named) ([]*TypeParam, Type, []*Func, []func())) *TypeName {
object.go#L287: case *TypeParam:
object.go#L600: } else if t, _ := typ.(*TypeParam); t != nil {
object.go#L688: } else if _, ok := obj.Type().(*TypeParam); ok {
operand.go#L194: tpar, _ := Unalias(x.typ).(*TypeParam)
operand.go#L328: Vp, _ := V.(*TypeParam)
operand.go#L329: Tp, _ := T.(*TypeParam)
predicates.go#L58: if tpar, _ := Unalias(t).(*TypeParam); tpar != nil {
predicates.go#L69: case *Basic, *Named, *TypeParam:
predicates.go#L80: case *Named, *TypeParam:
predicates.go#L124: _, ok := Unalias(t).(*TypeParam)
predicates.go#L133: if tpar, _ := Unalias(t).(*TypeParam); tpar != nil && tpar.bound != nil {
predicates.go#L490: case *TypeParam:
signature.go#L68: func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature {
signature.go#L275: recvTParams := make([]*TypeParam, len(rtparams))
signature.go#L499: 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(f func(t, u Type) bool) bool {
typestring.go#L309: case *TypeParam:
typestring.go#L407: func (w *typeWriter) tParamList(list []*TypeParam) {
under.go#L23: 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#L155: case *TypeParam:
go.pact.im/x/plumb/internal/emit
emit.go#L473: func renderLiftedHeader(lifted []*types.TypeParam, qual func(types.Type) string) string {
name.go#L93: case *types.TypeParam:
go.pact.im/x/plumb/internal/gotypes
cmp.go#L129: case *types.TypeParam:
cmp.go#L130: b := b.(*types.TypeParam)
cmp.go#L182: case *types.TypeParam:
gotypes.go#L117: case *types.Named, *types.TypeParam, *types.Basic:
subst.go#L20: func Subst(ctxt *types.Context, t types.Type, m map[*types.TypeParam]types.Type) types.Type {
subst.go#L26: m map[*types.TypeParam]types.Type
subst.go#L38: case *types.TypeParam:
subst.go#L126: tp, ok := x.(*types.TypeParam)
unify.go#L10: func Unify(pattern, concrete types.Type, params map[*types.TypeParam]bool, bind map[*types.TypeParam]types.Type) bool {
unify.go#L14: if tp, ok := pattern.(*types.TypeParam); ok && params[tp] {
unify.go#L100: func unifyTuple(p, c *types.Tuple, params map[*types.TypeParam]bool, bind map[*types.TypeParam]types.Type) bool {
unify.go#L116: func MentionsParams(t types.Type, params map[*types.TypeParam]bool) bool {
unify.go#L118: tp, ok := x.(*types.TypeParam)
unify.go#L126: func MentionsParam(t types.Type, tp *types.TypeParam) bool {
unify.go#L128: p, ok := x.(*types.TypeParam)
unify.go#L134: func IsBareTypeParam(t types.Type, params map[*types.TypeParam]bool) bool {
unify.go#L135: tp, ok := types.Unalias(t).(*types.TypeParam)
unify.go#L143: func IsPointerToBareTypeParam(t types.Type, params map[*types.TypeParam]bool) bool {
walk.go#L84: case *types.TypeParam:
walk.go#L111: _, ok := x.(*types.TypeParam)
walk.go#L130: case *types.Basic, *types.TypeParam:
go.pact.im/x/plumb/internal/solve
joint.go#L70: func (s *solver) jointClusters(p *discover.Provider) []map[*types.TypeParam]types.Type {
joint.go#L75: var clusters []map[*types.TypeParam]types.Type
joint.go#L144: func clusterCands(outs []types.Type, d types.Type, params map[*types.TypeParam]bool) (cands []map[*types.TypeParam]types.Type, matched bool) {
joint.go#L146: b := map[*types.TypeParam]types.Type{}
joint.go#L162: func (s *solver) jointClusterDone(p *discover.Provider, bind map[*types.TypeParam]types.Type) bool {
joint.go#L167: func (s *solver) markJointClusterDone(p *discover.Provider, bind map[*types.TypeParam]types.Type) {
joint.go#L183: func jointBindKey(p *discover.Provider, bind map[*types.TypeParam]types.Type) *types.Tuple {
lift.go#L38: m := make(map[*types.TypeParam]types.Type, p.Tparams.Len())
lift.go#L43: lifted := targs[i].(*types.TypeParam)
lift.go#L54: func (s *solver) liftOne(orig *types.TypeParam, p *discover.Provider) *types.TypeParam {
lift.go#L101: func (s *solver) orderedLifted() []*types.TypeParam {
lift.go#L105: out := make([]*types.TypeParam, len(meta))
revision.go#L37: func (s *solver) applyCommitment(p *discover.Provider, bind map[*types.TypeParam]types.Type) map[*types.TypeParam]types.Type {
revision.go#L56: func (s *solver) reviseOrSplit(p *discover.Provider, bind map[*types.TypeParam]types.Type) *diag.Error {
revision.go#L107: func (s *solver) unionRefused(p *discover.Provider, union map[*types.TypeParam]types.Type) bool {
revision.go#L112: func (s *solver) markUnionRefused(p *discover.Provider, union map[*types.TypeParam]types.Type) {
solve.go#L137: Lifted []*types.TypeParam // free type parameters carried onto the generic injector header
solve.go#L184: commitments map[*discover.Provider][]map[*types.TypeParam]types.Type
solve.go#L191: pinnings map[*Instance]map[*types.TypeParam]types.Type
solve.go#L197: tp *types.TypeParam
solve.go#L214: commitments := map[*discover.Provider][]map[*types.TypeParam]types.Type{}
solve.go#L234: pinnings: map[*Instance]map[*types.TypeParam]types.Type{},
solve.go#L439: b := map[*types.TypeParam]types.Type{}
solve.go#L470: func compatibleBind(a, b map[*types.TypeParam]types.Type) bool {
solve.go#L486: func (s *solver) bindInstantiates(p *discover.Provider, bind map[*types.TypeParam]types.Type) bool {
solve.go#L515: func (s *solver) instantiateTemplate(p *discover.Provider, bind map[*types.TypeParam]types.Type) (bool, *diag.Error) {
solve.go#L578: func (s *solver) nearMissDoneAt(p *discover.Provider, bind map[*types.TypeParam]types.Type) bool {
solve.go#L583: func (s *solver) markNearMissDone(p *discover.Provider, bind map[*types.TypeParam]types.Type) {
solve.go#L701: func (s *solver) templateServes(p *discover.Provider, skel *Instance, params map[*types.TypeParam]bool, d types.Type) bool {
solve.go#L708: b := map[*types.TypeParam]types.Type{}
solve.go#L759: bind map[*types.TypeParam]types.Type
solve.go#L802: b := map[*types.TypeParam]types.Type{}
solve.go#L844: func paramSet(p *discover.Provider) map[*types.TypeParam]bool {
solve.go#L845: m := map[*types.TypeParam]bool{}
solve.go#L857: func (s *solver) coversPinnable(p *discover.Provider, bind map[*types.TypeParam]types.Type) bool {
golang.org/x/exp/apidiff
correspondence.go#L126: case *types.TypeParam:
correspondence.go#L127: if new, ok := new.(*types.TypeParam); ok {
golang.org/x/tools/go/types/objectpath
objectpath.go#L290: if _, ok := types.Unalias(obj.Type()).(*types.TypeParam); !ok {
objectpath.go#L505: case *types.TypeParam:
objectpath.go#L876: tparam, ok := t.(*types.TypeParam)
golang.org/x/tools/go/types/typeutil
map.go#L312: case *types.TypeParam:
map.go#L357: func (h hasher) hashTypeParam(t *types.TypeParam) uint32 {
map.go#L455: case *types.TypeParam:
golang.org/x/tools/internal/aliases
aliases.go#L14: func New(pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
golang.org/x/tools/internal/gcimporter
iexport.go#L753: if tparam, ok := types.Unalias(t).(*types.TypeParam); ok {
iexport.go#L1039: case *types.TypeParam:
iexport.go#L1259: func tparamExportName(prefix string, tparam *types.TypeParam) string {
iimport.go#L365: t *types.TypeParam
iimport.go#L573: var tparams []*types.TypeParam
iimport.go#L588: var tparams []*types.TypeParam
iimport.go#L618: var tpars []*types.TypeParam
iimport.go#L629: var rparams []*types.TypeParam
iimport.go#L631: rparams = make([]*types.TypeParam, targs.Len())
iimport.go#L633: rparams[i] = types.Unalias(targs.At(i)).(*types.TypeParam)
iimport.go#L1054: func (r *importReader) signature(paramPkg *types.Package, recv *types.Var, rparams []*types.TypeParam, tparams []*types.TypeParam) *types.Signature {
iimport.go#L1061: func (r *importReader) tparamList() []*types.TypeParam {
iimport.go#L1066: xs := make([]*types.TypeParam, n)
iimport.go#L1070: xs[i] = types.Unalias(r.typ()).(*types.TypeParam)
ureader.go#L167: rtparams []*types.TypeParam // contains receiver type parameters for an element
ureader.go#L170: tparams []*types.TypeParam // contains type parameters for an element
ureader.go#L451: func (r *reader) signature(recv *types.Var, rtparams, tparams []*types.TypeParam) *types.Signature {
ureader.go#L549: var tparams []*types.TypeParam
ureader.go#L713: func (r *reader) typeParamNames(isGenMeth bool) []*types.TypeParam {
ureader.go#L721: var out *[]*types.TypeParam
ureader.go#L741: tparams := make([]*types.TypeParam, len(in))
golang.org/x/tools/internal/typeparams
common.go#L66: _, ok := types.Unalias(t).(*types.TypeParam)
coretype.go#L121: case *types.TypeParam:
free.go#L121: case *types.TypeParam:
normalize.go#L63: func StructuralTerms(tparam *types.TypeParam) ([]*types.Term, error) {
normalize.go#L164: if _, ok := embedded.Underlying().(*types.TypeParam); ok {
normalize.go#L185: case *types.TypeParam, *types.Union:
normalize.go#L200: case *types.TypeParam:
golang.org/x/tools/internal/typesinternal
element.go#L128: case *types.TypeParam, *types.Union:
types.go#L103: case *types.TypeParam:
types.go#L132: SetTypeParams(tparams []*types.TypeParam)
types.go#L211: } else if _, ok := obj.Type().(*types.TypeParam); ok {
zerovalue.go#L87: case *types.TypeParam:
zerovalue.go#L181: case *types.TypeParam:
zerovalue.go#L290: case *types.TypeParam: