type go/types.TypeName
105 uses
go/types (current package)
alias.go#L46: obj *TypeName // corresponding declared alias object
alias.go#L56: func NewAlias(obj *TypeName, rhs Type) *Alias {
alias.go#L65: func (a *Alias) Obj() *TypeName { return a.orig.obj }
alias.go#L134: func (check *Checker) newAlias(obj *TypeName, rhs Type) *Alias {
call.go#L751: case *TypeName:
check.go#L188: brokenAliases map[*TypeName]bool // set of aliases with broken (not yet determined) types
check.go#L195: methods map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
check.go#L229: func (check *Checker) brokenAlias(alias *TypeName) {
check.go#L232: check.brokenAliases = make(map[*TypeName]bool)
check.go#L239: func (check *Checker) validAlias(alias *TypeName, typ Type) {
check.go#L246: func (check *Checker) isBrokenAlias(alias *TypeName) bool {
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#L284: tname, _ := obj.(*TypeName)
decl.go#L517: func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec) {
decl.go#L726: func (check *Checker) collectMethods(obj *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#L191: func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
named.go#L323: func (check *Checker) newNamed(obj *TypeName, fromRHS Type, methods []*Func) *Named {
named.go#L375: 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#L520: var tname *TypeName
object.go#L534: case *TypeName:
object.go#L648: func (obj *TypeName) String() string { return ObjectString(obj, nil) }
object.go#L685: case *TypeName:
resolver.go#L490: check.methods = make(map[*TypeName][]*Func)
resolver.go#L566: func (check *Checker) resolveBaseTypeName(ptr bool, name *ast.Ident) (ptr_ bool, base *TypeName) {
resolver.go#L570: var seen map[*TypeName]bool
resolver.go#L580: tname, _ := obj.(*TypeName)
resolver.go#L604: seen = make(map[*TypeName]bool)
resolver.go#L639: if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil {
resolver.go#L670: var aliasList []*TypeName
resolver.go#L674: if tname, _ := obj.(*TypeName); tname != nil {
signature.go#L515: 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#L436: func (w *typeWriter) typeName(obj *TypeName) {
typexpr.go#L50: _, gotType := obj.(*TypeName)
typexpr.go#L110: case *TypeName:
typexpr.go#L192: func (check *Checker) declaredType(e ast.Expr, def *TypeName) Type {
typexpr.go#L232: func (check *Checker) typInternal(e0 ast.Expr, def *TypeName) (T Type) {
typexpr.go#L450: name := inst.(interface{ Obj() *TypeName }).Obj().name
universe.go#L30: universeAnyNoAlias *TypeName
universe.go#L31: universeAnyAlias *TypeName
universe.go#L298: typ.obj = obj.(*TypeName)
universe.go#L306: 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#L158: if tn, ok := oldobj.(*types.TypeName); ok {
apidiff.go#L261: case *types.TypeName:
apidiff.go#L262: if new, ok := new.(*types.TypeName); ok {
apidiff.go#L298: case *types.TypeName:
compatibility.go#L9: func (d *differ) checkCompatible(otn *types.TypeName, old, new types.Type) {
compatibility.go#L47: func (d *differ) checkCompatibleChan(otn *types.TypeName, old, new *types.Chan) {
compatibility.go#L58: func (d *differ) checkCompatibleBasic(otn *types.TypeName, old, new *types.Basic) {
compatibility.go#L111: func (d *differ) checkCompatibleInterface(otn *types.TypeName, old, new *types.Interface) {
compatibility.go#L261: func (d *differ) checkCompatibleDefined(otn *types.TypeName, old *types.Named, new types.Type) {
compatibility.go#L284: func (d *differ) checkMethodSet(otn *types.TypeName, oldt, newt types.Type, addcompat bool) {
golang.org/x/tools/go/types/objectpath
objectpath.go#L146: seenTParamNames map[*types.TypeName]bool // global cycle breaking through type parameters
objectpath.go#L280: if _, ok := obj.(*types.TypeName); !ok && !obj.Exported() {
objectpath.go#L289: case *types.TypeName:
objectpath.go#L380: if _, ok := obj.(*types.TypeName); !ok {
objectpath.go#L416: if tname, ok := obj.(*types.TypeName); !ok {
objectpath.go#L512: tr.seenTParamNames = make(map[*types.TypeName]bool)
objectpath.go#L756: Obj() *types.TypeName
golang.org/x/tools/go/types/typeutil
callee.go#L26: if _, ok := obj.(*types.TypeName); ok {
map.go#L378: func (hasher) hashTypeName(tname *types.TypeName) uint32 {
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#L750: case *types.TypeName:
iexport.go#L961: func (w *exportWriter) qualifiedType(obj *types.TypeName) {
iimport.go#L564: var markBlack = func(name *types.TypeName) {}
iimport.go#L896: return pkg.Scope().Lookup(name).(*types.TypeName).Type()
ureader.go#L352: name := obj.(*types.TypeName)
golang.org/x/tools/internal/typesinternal
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: