type go/types.TypeName
94 uses
go/types (current package)
alias.go#L47: obj *TypeName // corresponding declared alias object
alias.go#L57: func NewAlias(obj *TypeName, rhs Type) *Alias {
alias.go#L66: func (a *Alias) Obj() *TypeName { return a.orig.obj }
alias.go#L144: func (check *Checker) newAlias(obj *TypeName, rhs Type) *Alias {
call.go#L674: func (check *Checker) selector(x *operand, e *ast.SelectorExpr, def *TypeName, wantType bool) {
call.go#L744: case *TypeName:
check.go#L183: brokenAliases map[*TypeName]bool // set of aliases with broken (not yet determined) types
check.go#L190: methods map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
check.go#L222: func (check *Checker) brokenAlias(alias *TypeName) {
check.go#L225: check.brokenAliases = make(map[*TypeName]bool)
check.go#L232: func (check *Checker) validAlias(alias *TypeName, typ Type) {
check.go#L239: func (check *Checker) isBrokenAlias(alias *TypeName) bool {
decl.go#L51: func (check *Checker) objDecl(obj Object, def *TypeName) {
decl.go#L137: case *TypeName:
decl.go#L188: case *TypeName:
decl.go#L226: case *TypeName:
decl.go#L312: tname, _ := obj.(*TypeName)
decl.go#L541: func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *TypeName) {
decl.go#L747: 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#L111: obj *TypeName // corresponding declared object for declared types; see above for instantiated types
named.go#L158: func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
named.go#L243: func (check *Checker) newNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
named.go#L307: func (t *Named) Obj() *TypeName {
object.go#L282: type TypeName struct {
object.go#L293: func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName {
object.go#L294: return &TypeName{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}}
object.go#L299: func _NewTypeNameLazy(pos token.Pos, pkg *Package, name string, load func(named *Named) (tparams []*TypeParam, underlying Type, methods []*Func)) *TypeName {
object.go#L306: func (obj *TypeName) IsAlias() bool {
object.go#L509: var tname *TypeName
object.go#L523: case *TypeName:
object.go#L637: func (obj *TypeName) String() string { return ObjectString(obj, nil) }
resolver.go#L492: check.methods = make(map[*TypeName][]*Func)
resolver.go#L555: func (check *Checker) resolveBaseTypeName(ptr bool, name *ast.Ident) (ptr_ bool, base *TypeName) {
resolver.go#L559: var seen map[*TypeName]bool
resolver.go#L569: tname, _ := obj.(*TypeName)
resolver.go#L593: 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#L466: 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#L21: func (check *Checker) ident(x *operand, e *ast.Ident, def *TypeName, wantType bool) {
typexpr.go#L51: _, gotType := obj.(*TypeName)
typexpr.go#L110: case *TypeName:
typexpr.go#L192: func (check *Checker) definedType(e ast.Expr, def *TypeName) Type {
typexpr.go#L232: func (check *Checker) typInternal(e0 ast.Expr, def *TypeName) (T Type) {
typexpr.go#L418: func setDefType(def *TypeName, typ Type) {
typexpr.go#L433: func (check *Checker) instantiatedType(ix *indexedExpr, def *TypeName) (res Type) {
typexpr.go#L485: name := inst.(interface{ Obj() *TypeName }).Obj().name
universe.go#L30: universeAnyNoAlias *TypeName
universe.go#L31: universeAnyAlias *TypeName
universe.go#L300: typ.obj = obj.(*TypeName)
universe.go#L308: case *TypeName:
golang.org/x/exp/apidiff
apidiff.go#L43: correspondMap map[*types.TypeName]types.Type
apidiff.go#L54: correspondMap: map[*types.TypeName]types.Type{},
apidiff.go#L143: case *types.TypeName:
apidiff.go#L144: if new, ok := new.(*types.TypeName); ok {
apidiff.go#L180: 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#L221: if _, ok := obj.(*types.TypeName); !ok && !obj.Exported() {
objectpath.go#L230: case *types.TypeName:
objectpath.go#L274: tname, ok := o.(*types.TypeName)
objectpath.go#L312: if _, ok := o.(*types.TypeName); !ok {
objectpath.go#L464: seenTParamNames map[*types.TypeName]bool // for cycle breaking through type parameters
objectpath.go#L552: f.seenTParamNames = make(map[*types.TypeName]bool)
objectpath.go#L608: Obj() *types.TypeName
golang.org/x/tools/go/types/typeutil
callee.go#L25: if _, ok := obj.(*types.TypeName); ok {
map.go#L380: func (hasher) hashTypeName(tname *types.TypeName) uint32 {
golang.org/x/tools/internal/aliases
aliases.go#L28: func NewAlias(enabled bool, pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
golang.org/x/tools/internal/gcimporter
iexport.go#L752: case *types.TypeName:
iexport.go#L954: func (w *exportWriter) qualifiedType(obj *types.TypeName) {
iimport.go#L566: var markBlack = func(name *types.TypeName) {}
iimport.go#L894: return pkg.Scope().Lookup(name).(*types.TypeName).Type()
ureader_yes.go#L350: name := obj.(*types.TypeName)
golang.org/x/tools/internal/typesinternal
types.go#L83: func TypeNameFor(t types.Type) *types.TypeName {
types.go#L93: if tname, ok := types.Universe.Lookup(t.Name()).(*types.TypeName); ok {
types.go#L115: Obj() *types.TypeName