type go/types.Named
137 uses
go/types (current package)
builtins.go#L814: case *Named, *Union:
call.go#L432: func (check *Checker) selector(x *operand, e *ast.SelectorExpr, def *Named) {
check.go#L108: infoMap map[*Named]typeInfo // maps named types to their associated type info (for cycle detection)
check.go#L252: infoMap: make(map[*Named]typeInfo),
decl.go#L55: func (check *Checker) objDecl(obj Object, def *Named) {
decl.go#L525: named, _ := typ.(*Named)
decl.go#L533: func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
decl.go#L538: if t, _ := obj.typ.(*Named); t != nil { // type may be invalid
decl.go#L712: base, _ := obj.typ.(*Named) // shouldn't fail but be conservative
decl.go#L750: func (check *Checker) checkFieldUniqueness(base *Named) {
expr.go#L1227: case *Named:
infer.go#L436: case *Named:
infer.go#L768: case *Named:
instantiate.go#L46: case *Named:
instantiate.go#L78: case *Named:
instantiate.go#L82: named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, *methodList) {
interface.go#L39: func NewInterface(methods []*Func, embeddeds []*Named) *Interface {
interface.go#L107: func (t *Interface) Embedded(i int) *Named { tname, _ := t.embeddeds[i].(*Named); return tname }
interface.go#L158: func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *Named) {
lookup.go#L56: if t, _ := T.(*Named); t != nil {
lookup.go#L125: if named, _ := typ.(*Named); named != nil {
lookup.go#L265: m map[*Named][]*Named
lookup.go#L268: func (l *instanceLookup) lookup(inst *Named) *Named {
lookup.go#L277: func (l *instanceLookup) add(inst *Named) {
lookup.go#L279: l.m = make(map[*Named][]*Named)
methodset.go#L112: if named, _ := typ.(*Named); named != nil {
mono.go#L151: case *Named:
mono.go#L216: case *Named:
mono.go#L263: func (w *monoGraph) localNamedVertex(pkg *Package, named *Named) int {
named.go#L13: type Named struct {
named.go#L16: orig *Named // original, uninstantiated type
named.go#L30: resolver func(*Context, *Named) (tparams *TypeParamList, underlying Type, methods *methodList)
named.go#L37: func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
named.go#L38: if _, ok := underlying.(*Named); ok {
named.go#L44: func (t *Named) resolve(ctxt *Context) *Named {
named.go#L65: func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TypeParamList, methods *methodList) *Named {
named.go#L66: typ := &Named{check: check, obj: obj, orig: orig, fromRHS: underlying, underlying: underlying, tparams: tparams, methods: methods}
named.go#L80: func (t *Named) cleanup() {
named.go#L94: case *Named:
named.go#L102: func (t *Named) Obj() *TypeName {
named.go#L108: func (t *Named) Origin() *Named { return t.orig }
named.go#L115: func (t *Named) TypeParams() *TypeParamList { return t.resolve(nil).tparams }
named.go#L119: func (t *Named) SetTypeParams(tparams []*TypeParam) {
named.go#L125: func (t *Named) TypeArgs() *TypeList { return t.targs }
named.go#L132: func (t *Named) NumMethods() int { return t.resolve(nil).methods.Len() }
named.go#L135: func (t *Named) Method(i int) *Func {
named.go#L143: func (t *Named) instantiateMethod(i int) *Func {
named.go#L201: func (t *Named) SetUnderlying(underlying Type) {
named.go#L206: if _, ok := underlying.(*Named); ok {
named.go#L217: func (t *Named) AddMethod(m *Func) {
named.go#L226: func (t *Named) Underlying() Type { return t.resolve(nil).underlying }
named.go#L227: func (t *Named) String() string { return TypeString(t, nil) }
named.go#L250: func (n0 *Named) under() Type {
named.go#L256: var n1 *Named
named.go#L265: case *Named:
named.go#L279: seen := make(map[*Named]int) // types that need their underlying resolved
named.go#L300: case *Named:
named.go#L320: func (n *Named) setUnderlying(typ Type) {
named.go#L326: func (n *Named) lookupMethod(pkg *Package, name string, foldCase bool) (int, *Func) {
named.go#L358: func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParamList, underlying Type, methods *methodList) {
named.go#L364: if _, unexpanded := n.orig.underlying.(*Named); unexpanded {
named.go#L411: if t, _ := typ.(*Named); t != nil {
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#L238: resolve := func(_ *Context, t *Named) (*TypeParamList, Type, *methodList) {
object.go#L242: case nil, *Named:
object.go#L270: case *Named:
object.go#L469: case *Named:
predicates.go#L63: case *Basic, *Named, *TypeParam:
predicates.go#L101: named, _ := t.(*Named)
predicates.go#L387: case *Named:
predicates.go#L390: if y, ok := y.(*Named); ok {
signature.go#L140: if recv, _ := check.genericType(rname, nil).(*Named); recv != nil {
signature.go#L216: case *Named:
subst.go#L197: case *Named:
type.go#L22: if t, _ := t.(*Named); t != nil {
typeparam.go#L137: if n, _ := bound.(*Named); n != nil {
typestring.go#L213: if t == universeComparable.Type().(*Named).underlying {
typestring.go#L282: case *Named:
typexpr.go#L22: func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool) {
typexpr.go#L181: func (check *Checker) definedType(e ast.Expr, def *Named) Type {
typexpr.go#L218: func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
typexpr.go#L393: func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (res Type) {
typexpr.go#L414: orig, _ := gtyp.(*Named)
typexpr.go#L434: inst, _ := ctxt.lookup(h, orig, targs).(*Named)
typexpr.go#L444: inst = ctxt.update(h, orig, targs, inst).(*Named)
typexpr.go#L448: inst.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, *methodList) {
unify.go#L315: if nx, _ := x.(*Named); nx != nil && !hasName(y) {
unify.go#L320: } else if ny, _ := y.(*Named); ny != nil && !hasName(x) {
unify.go#L545: case *Named:
unify.go#L547: if y, ok := y.(*Named); ok {
universe.go#L257: if typ, _ := obj.Type().(*Named); typ != nil {
validtype.go#L12: func (check *Checker) validType(typ *Named) {
validtype.go#L63: case *Named:
validtype.go#L117: func (env *tparamEnv) push(typ *Named) *tparamEnv {
golang.org/x/exp/apidiff
compatibility.go#L35: case *types.Named:
compatibility.go#L261: func (d *differ) checkCompatibleDefined(otn *types.TypeName, old *types.Named, new types.Type) {
compatibility.go#L350: func receiverNamedType(method types.Object) *types.Named {
compatibility.go#L353: return t.Elem().(*types.Named)
compatibility.go#L354: case *types.Named:
correspondence.go#L119: case *types.Named:
correspondence.go#L120: if new, ok := new.(*types.Named); ok {
correspondence.go#L149: if on, ok := of.Type().(*types.Named); ok {
correspondence.go#L150: nn := nf.Type().(*types.Named)
correspondence.go#L159: func (d *differ) establishCorrespondence(old *types.Named, new types.Type) bool {
correspondence.go#L184: if newn, ok := new.(*types.Named); ok {
correspondence.go#L229: oldn, ok := old.(*types.Named)
correspondence.go#L233: newn, ok := new.(*types.Named)
golang.org/x/tools/internal/gcimporter
bexport.go#L328: case *types.Named:
bexport.go#L387: func (p *exporter) assocMethods(named *types.Named) {
bexport.go#L525: case *types.Named:
bimport.go#L420: func (p *importer) typ(parent *types.Package, tname *types.Named) types.Type {
bimport.go#L450: tname := obj.Type().(*types.Named) // tname is either t0 or the existing type
bimport.go#L630: case *types.Named:
bimport.go#L644: func (p *importer) methodList(parent *types.Package, baseType *types.Named) (methods []*types.Func) {
bimport.go#L654: func (p *importer) method(parent *types.Package, baseType *types.Named) *types.Func {
iexport.go#L509: named, ok := t.(*types.Named)
iexport.go#L715: case *types.Named:
iexport.go#L797: if named, _ := ft.(*types.Named); named != nil {
iimport.go#L430: func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
iimport.go#L455: func canReuse(def *types.Named, rhs types.Type) bool {
iimport.go#L774: func (r *importReader) doType(base *types.Named) (res types.Type) {
iimport.go#L968: func baseType(typ types.Type) *types.Named {
iimport.go#L974: n, _ := typ.(*types.Named)
golang.org/x/tools/internal/typeparams
common.go#L98: named, isNamed := base.(*types.Named)
common.go#L139: VN, Vnamed := V.(*types.Named)
common.go#L140: TN, Tnamed := T.(*types.Named)
typeparams_go118.go#L90: func ForNamed(named *types.Named) *TypeParamList {
typeparams_go118.go#L96: func SetForNamed(n *types.Named, tparams []*TypeParam) {
typeparams_go118.go#L101: func NamedTypeArgs(named *types.Named) *TypeList {
typeparams_go118.go#L106: func NamedTypeOrigin(named *types.Named) types.Type {