type go/types.TypeName
100 uses
go/types (current package)
alias.go#L28: obj *TypeName // corresponding declared alias object
alias.go#L38: func NewAlias(obj *TypeName, rhs Type) *Alias {
alias.go#L47: func (a *Alias) Obj() *TypeName { return a.orig.obj }
alias.go#L116: func (check *Checker) newAlias(obj *TypeName, rhs Type) *Alias {
call.go#L763: case *TypeName:
check.go#L150: brokenAliases map[*TypeName]bool // set of aliases with broken (not yet determined) types
check.go#L157: methods map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
cycles.go#L15: pathIdx := make(map[*TypeName]int)
cycles.go#L17: if tname, ok := obj.(*TypeName); ok {
cycles.go#L42: func (check *Checker) directCycle(tname *TypeName, pathIdx map[*TypeName]int) {
cycles.go#L47: var path []*TypeName
cycles.go#L87: tname1, ok := check.pkg.scope.Lookup(rhs.Name).(*TypeName)
decl.go#L108: case *TypeName:
decl.go#L157: case *TypeName:
decl.go#L195: case *TypeName:
decl.go#L269: tname, _ := obj.(*TypeName)
decl.go#L496: func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec) {
decl.go#L675: func (check *Checker) collectMethods(obj *TypeName) {
hash.go#L210: func (hasher) hashTypeName(h *maphash.Hash, tname *TypeName) {
interface.go#L159: func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *TypeName) {
mono.go#L65: nameIdx map[*TypeName]int
mono.go#L75: obj *TypeName
mono.go#L290: if elem, ok := elem.(*TypeName); ok && !elem.IsAlias() && cmpPos(elem.Pos(), obj.Pos()) < 0 {
mono.go#L304: w.nameIdx = make(map[*TypeName]int)
mono.go#L323: w.nameIdx = make(map[*TypeName]int)
named.go#L110: obj *TypeName // corresponding declared object for declared types; see above for instantiated types
named.go#L189: func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
named.go#L326: func (check *Checker) newNamed(obj *TypeName, fromRHS Type, methods []*Func) *Named {
named.go#L378: func (t *Named) Obj() *TypeName {
object.go#L242: type TypeName struct {
object.go#L253: func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName {
object.go#L254: return &TypeName{object{nil, pos, pkg, name, typ, 0, nopos}}
object.go#L259: func _NewTypeNameLazy(pos token.Pos, pkg *Package, name string, load func(*Named) ([]*TypeParam, Type, []*Func, []func())) *TypeName {
object.go#L267: func (obj *TypeName) IsAlias() bool {
object.go#L521: var tname *TypeName
object.go#L535: case *TypeName:
object.go#L649: func (obj *TypeName) String() string { return ObjectString(obj, nil) }
object.go#L686: case *TypeName:
resolver.go#L489: check.methods = make(map[*TypeName][]*Func)
resolver.go#L565: func (check *Checker) resolveBaseTypeName(ptr bool, name *ast.Ident) (ptr_ bool, base *TypeName) {
resolver.go#L569: var seen map[*TypeName]bool
resolver.go#L579: tname, _ := obj.(*TypeName)
resolver.go#L603: seen = make(map[*TypeName]bool)
resolver.go#L638: if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil {
resolver.go#L668: var aliasList []*TypeName
resolver.go#L672: if tname, _ := obj.(*TypeName); tname != nil {
signature.go#L514: func isCGoTypeObj(fset *token.FileSet, obj *TypeName) bool {
typeparam.go#L28: obj *TypeName // corresponding type name
typeparam.go#L39: func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
typeparam.go#L44: func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
typeparam.go#L66: func (t *TypeParam) Obj() *TypeName { return t.obj }
typestring.go#L131: if obj, _ := Unsafe.scope.Lookup(t.name).(*TypeName); obj != nil {
typestring.go#L432: func (w *typeWriter) typeName(obj *TypeName) {
typexpr.go#L43: _, gotType := obj.(*TypeName)
typexpr.go#L103: case *TypeName:
typexpr.go#L181: func (check *Checker) declaredType(e ast.Expr, def *TypeName) Type {
typexpr.go#L221: func (check *Checker) typInternal(e0 ast.Expr, def *TypeName) (T Type) {
typexpr.go#L439: name := inst.(interface{ Obj() *TypeName }).Obj().name
universe.go#L270: typ.obj = obj.(*TypeName)
universe.go#L278: case *TypeName:
go.pact.im/x/plumb/internal/discover
discover.go#L543: tn, _ := pkg.Info.Defs[s.Name].(*types.TypeName)
discover.go#L622: func structProviders(pkg *Package, s *ast.TypeSpec, tn *types.TypeName, names []string) ([]*Provider, *diag.Error) {
go.pact.im/x/plumb/internal/gotypes
cmp.go#L215: func cmpTypeName(a, b *types.TypeName) int {
gotypes.go#L246: func TypeNameOf(t types.Type) *types.TypeName {
walk.go#L14: func WalkNamed(t types.Type, visit func(*types.TypeName) bool) {
walk.go#L20: func walkNamed(t types.Type, seen *Set[types.Type], visit func(*types.TypeName) bool) {
walk.go#L91: func walkTuple(tup *types.Tuple, seen *Set[types.Type], visit func(*types.TypeName) bool) {
go.pact.im/x/plumb/internal/solve
checks.go#L119: func findUnreachable(t types.Type, destPath string) (*types.TypeName, bool) {
checks.go#L120: var found *types.TypeName
checks.go#L121: gotypes.WalkNamed(t, func(tn *types.TypeName) bool {
golang.org/x/exp/apidiff
apidiff.go#L148: tn, ok := obj.(*types.TypeName)
apidiff.go#L258: case *types.TypeName:
apidiff.go#L259: if new, ok := new.(*types.TypeName); ok {
apidiff.go#L295: case *types.TypeName:
compatibility.go#L11: func (d *differ) checkCompatible(otn *types.TypeName, old, new types.Type) {
compatibility.go#L49: func (d *differ) checkCompatibleChan(otn *types.TypeName, old, new *types.Chan) {
compatibility.go#L60: func (d *differ) checkCompatibleBasic(otn *types.TypeName, old, new *types.Basic) {
compatibility.go#L113: func (d *differ) checkCompatibleInterface(otn *types.TypeName, old, new *types.Interface) {
compatibility.go#L266: func (d *differ) checkCompatibleDefined(otn *types.TypeName, old *types.Named, new types.Type) {
compatibility.go#L289: func (d *differ) checkMethodSet(otn *types.TypeName, oldt, newt types.Type, addcompat bool) {
correspondence.go#L172: ntn, ok := newobj.(*types.TypeName)
golang.org/x/tools/go/types/objectpath
objectpath.go#L147: seenTParamNames map[*types.TypeName]bool // global cycle breaking through type parameters
objectpath.go#L283: if _, ok := obj.(*types.TypeName); !ok && !obj.Exported() {
objectpath.go#L292: case *types.TypeName:
objectpath.go#L386: if _, ok := obj.(*types.TypeName); !ok {
objectpath.go#L422: if tname, ok := obj.(*types.TypeName); !ok {
objectpath.go#L518: tr.seenTParamNames = make(map[*types.TypeName]bool)
objectpath.go#L767: Obj() *types.TypeName
golang.org/x/tools/go/types/typeutil
map.go#L378: func (hasher) hashTypeName(tname *types.TypeName) uint32 {
golang.org/x/tools/internal/gcimporter
iexport.go#L715: case *types.TypeName:
iexport.go#L926: func (w *exportWriter) qualifiedType(obj *types.TypeName) {
iimport.go#L529: var markBlack = func(name *types.TypeName) {}
iimport.go#L866: return pkg.Scope().Lookup(name).(*types.TypeName).Type()
ureader.go#L351: name := obj.(*types.TypeName)
golang.org/x/tools/internal/typesinternal
classify_call.go#L168: if _, ok := obj.(*types.TypeName); ok {
types.go#L97: func TypeNameFor(t types.Type) *types.TypeName {
types.go#L107: if tname, ok := types.Universe.Lookup(t.Name()).(*types.TypeName); ok {
types.go#L129: Obj() *types.TypeName
types.go#L208: case *types.TypeName: