type go/types.Signature
111 uses
go/types (current package)
assignments.go#L97: if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
assignments.go#L267: if _, ok := under(T).(*Signature); ok {
builtins.go#L99: var sig *Signature
builtins.go#L1088: func makeSig(res Type, args ...Type) *Signature {
builtins.go#L1099: return &Signature{params: params, results: result}
call.go#L62: sig := x.typ.(*Signature)
call.go#L132: func (check *Checker) instantiateSignature(pos token.Pos, expr ast.Expr, typ *Signature, targs []Type, xlist []ast.Expr) (res *Signature) {
call.go#L148: inst := check.instance(pos, typ, targs, nil, check.context()).(*Signature)
call.go#L250: if _, ok := u.(*Signature); u != nil && !ok {
call.go#L261: sig := u.(*Signature) // u must be a signature per the commonUnder condition
call.go#L373: assert(n < x.typ.(*Signature).TypeParams().Len())
call.go#L462: func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type, xlist []ast.Expr, args []*operand, atargs [][]Type) (rsig *Signature) {
call.go#L573: if asig, _ := arg.typ.(*Signature); asig != nil && asig.TypeParams().Len() > 0 {
call.go#L586: asig = tmp.(*Signature)
call.go#L643: asig := arg.typ.(*Signature)
call.go#L765: x.typ = x.typ.(*Signature).results.vars[0].typ
call.go#L863: sig := m.typ.(*Signature)
call.go#L891: x.typ = &Signature{
call.go#L965: sig := *obj.typ.(*Signature)
check.go#L83: sig *Signature // function signature if inside a function; nil otherwise
decl.go#L851: sig := new(Signature)
expr.go#L469: case *Pointer, *Signature, *Slice, *Map, *Chan:
expr.go#L609: case *Slice, *Signature, *Map:
expr.go#L946: sig *Signature
expr.go#L954: if sig, _ := under(typ).(*Signature); sig != nil {
expr.go#L1002: case *Signature:
index.go#L39: if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
infer.go#L438: if sig, _ := t1.(*Signature); sig != nil && sig.TypeParams().Len() > 0 && !isParameterized(tparams, sig) {
infer.go#L598: case *Signature:
infer.go#L750: case *Signature:
instantiate.go#L155: case *Signature:
instantiate.go#L166: sig := check.subst(pos, orig, makeSubstMap(tparams.list(), targs), nil, ctxt).(*Signature)
interface.go#L61: if sig := m.typ.(*Signature); sig.recv == nil {
interface.go#L183: sig, _ := typ.(*Signature)
literals.go#L84: if sig, ok := check.typ(e.Type).(*Signature); ok {
lookup.go#L579: w.signature(f.typ.(*Signature))
mono.go#L250: case *Signature:
named.go#L406: origSig := origm.typ.(*Signature)
named.go#L430: sig = check.subst(origm.pos, origSig, smap, t, ctxt).(*Signature)
object.go#L447: func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func {
object.go#L461: func (obj *Func) Signature() *Signature {
object.go#L463: return obj.typ.(*Signature) // normal case
object.go#L473: return new(Signature)
object.go#L487: func (obj *Func) Scope() *Scope { return obj.typ.(*Signature).scope }
object.go#L515: if sig, _ := obj.typ.(*Signature); sig != nil && sig.recv != nil {
object.go#L591: WriteSignature(buf, typ.(*Signature), qf)
object.go#L696: sig := f.typ.(*Signature)
operand.go#L247: case *Signature:
predicates.go#L215: case *Slice, *Pointer, *Signature, *Map, *Chan:
predicates.go#L331: case *Signature:
predicates.go#L332: y, _ := y.(*Signature)
range.go#L242: case *Signature:
range.go#L256: cb, _ := u.(*Signature)
recording.go#L77: func (check *Checker) recordBuiltinType(f ast.Expr, sig *Signature) {
selection.go#L100: sig := *s.obj.(*Func).typ.(*Signature)
selection.go#L111: sig := *s.obj.(*Func).typ.(*Signature)
selection.go#L180: WriteSignature(&buf, T.(*Signature), qf)
signature.go#L21: type Signature struct {
signature.go#L43: func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
signature.go#L57: func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature {
signature.go#L84: sig := &Signature{recv: recv, params: params, results: results, variadic: variadic}
signature.go#L106: func (s *Signature) Recv() *Var { return s.recv }
signature.go#L109: func (s *Signature) TypeParams() *TypeParamList { return s.tparams }
signature.go#L112: func (s *Signature) RecvTypeParams() *TypeParamList { return s.rparams }
signature.go#L115: func (s *Signature) Params() *Tuple { return s.params }
signature.go#L118: func (s *Signature) Results() *Tuple { return s.results }
signature.go#L121: func (s *Signature) Variadic() bool { return s.variadic }
signature.go#L123: func (s *Signature) Underlying() Type { return s }
signature.go#L124: func (s *Signature) String() string { return TypeString(s, nil) }
signature.go#L130: func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast.FuncType) {
stmt.go#L18: func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *ast.BlockStmt, iota constant.Value) {
subst.go#L151: case *Signature:
subst.go#L170: return &Signature{
typestring.go#L66: func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
typestring.go#L194: case *Signature:
typestring.go#L250: w.signature(m.typ.(*Signature))
typestring.go#L370: w.signature(m.typ.(*Signature))
typestring.go#L476: func (w *typeWriter) signature(sig *Signature) {
typexpr.go#L349: typ := new(Signature)
typexpr.go#L455: if _, ok := typ.(*Signature); ok {
unify.go#L647: case *Signature:
unify.go#L653: if y, ok := y.(*Signature); ok {
golang.org/x/exp/apidiff
apidiff.go#L325: sig, ok := t.(*types.Signature)
compatibility.go#L347: return method.Type().(*types.Signature).Recv().Type()
correspondence.go#L64: case *types.Signature:
correspondence.go#L65: if new, ok := new.(*types.Signature); ok {
messageset.go#L91: sig := f.Type().(*types.Signature)
golang.org/x/tools/go/types/objectpath
objectpath.go#L252: if recv := obj.Type().(*types.Signature).Recv(); recv == nil {
objectpath.go#L408: _, named := typesinternal.ReceiverNamed(meth.Type().(*types.Signature).Recv())
objectpath.go#L489: case *types.Signature:
objectpath.go#L675: sig, ok := t.(*types.Signature)
objectpath.go#L682: sig, ok := t.(*types.Signature)
objectpath.go#L720: sig, ok := t.(*types.Signature) // Signature
golang.org/x/tools/go/types/typeutil
map.go#L252: case *types.Signature:
map.go#L409: case *types.Signature:
golang.org/x/tools/internal/gcimporter
iexport.go#L717: sig, _ := obj.Type().(*types.Signature)
iexport.go#L827: sig, _ := m.Type().(*types.Signature)
iexport.go#L1066: case *types.Signature:
iexport.go#L1141: sig, _ := m.Type().(*types.Signature)
iexport.go#L1217: func (w *exportWriter) signature(sig *types.Signature) {
iimport.go#L1052: func (r *importReader) signature(recv *types.Var, rparams []*types.TypeParam, tparams []*types.TypeParam) *types.Signature {
ureader_yes.go#L445: func (r *reader) signature(recv *types.Var, rtparams, tparams []*types.TypeParam) *types.Signature {
ureader_yes.go#L573: sig := fn.Type().(*types.Signature)
golang.org/x/tools/internal/typeparams
free.go#L79: case *types.Signature:
golang.org/x/tools/internal/typesinternal
element.go#L39: sig := tmset.At(i).Type().(*types.Signature)
element.go#L91: case *types.Signature:
zerovalue.go#L54: case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
zerovalue.go#L147: case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
zerovalue.go#L270: case *types.Signature: