type go/types.TypeName

69 uses

	go/types (current package)
		call.go#L500: 			case *TypeName:
		check.go#L127: 	brokenAliases map[*TypeName]bool        // set of aliases with broken (not yet determined) types
		check.go#L132: 	methods  map[*TypeName][]*Func // maps package scope type names to associated non-blank (non-interface) methods
		check.go#L160: func (check *Checker) brokenAlias(alias *TypeName) {
		check.go#L162: 		check.brokenAliases = make(map[*TypeName]bool)
		check.go#L169: func (check *Checker) validAlias(alias *TypeName, typ Type) {
		check.go#L175: func (check *Checker) isBrokenAlias(alias *TypeName) bool {
		decl.go#L141: 		case *TypeName:
		decl.go#L194: 	case *TypeName:
		decl.go#L232: 		case *TypeName:
		decl.go#L311: 	tname, _ := obj.(*TypeName)
		decl.go#L533: func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
		decl.go#L695: func (check *Checker) collectMethods(obj *TypeName) {
		interface.go#L18: 	obj       *TypeName    // type name object defining this interface; or nil (for better error messages)
		mono.go#L61: 	nameIdx map[*TypeName]int
		mono.go#L71: 	obj *TypeName
		mono.go#L284: 			if elem, ok := elem.(*TypeName); ok && !elem.IsAlias() && elem.Pos() < obj.Pos() {
		mono.go#L298: 		w.nameIdx = make(map[*TypeName]int)
		mono.go#L317: 		w.nameIdx = make(map[*TypeName]int)
		named.go#L15: 	obj        *TypeName      // corresponding declared object for declared types; placeholder for instantiated types
		named.go#L37: func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
		named.go#L65: func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TypeParamList, methods *methodList) *Named {
		named.go#L102: func (t *Named) Obj() *TypeName {
		object.go#L218: type TypeName struct {
		object.go#L229: func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName {
		object.go#L230: 	return &TypeName{object{nil, pos, pkg, name, typ, 0, colorFor(typ), token.NoPos}}
		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#L254: func (obj *TypeName) IsAlias() bool {
		object.go#L399: 	var tname *TypeName
		object.go#L413: 	case *TypeName:
		object.go#L523: func (obj *TypeName) String() string { return ObjectString(obj, nil) }
		resolver.go#L480: 	check.methods = make(map[*TypeName][]*Func)
		resolver.go#L552: func (check *Checker) resolveBaseTypeName(seenPtr bool, name *ast.Ident) (ptr bool, base *TypeName) {
		resolver.go#L559: 	var seen map[*TypeName]bool
		resolver.go#L588: 		tname, _ := obj.(*TypeName)
		resolver.go#L608: 			seen = make(map[*TypeName]bool)
		resolver.go#L627: 		if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil {
		resolver.go#L637: 	var aliasList []*TypeName
		resolver.go#L641: 		if tname, _ := obj.(*TypeName); tname != nil {
		typeparam.go#L24: 	obj   *TypeName // corresponding type name
		typeparam.go#L35: func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
		typeparam.go#L40: func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
		typeparam.go#L68: func (t *TypeParam) Obj() *TypeName { return t.obj }
		typestring.go#L135: 			if obj, _ := Unsafe.scope.Lookup(t.name).(*TypeName); obj != nil {
		typestring.go#L397: func (w *typeWriter) typeName(obj *TypeName) {
		typexpr.go#L62: 	if _, gotType := obj.(*TypeName); typ == nil || gotType && wantType {
		typexpr.go#L98: 	case *TypeName:
		universe.go#L258: 		typ.obj = obj.(*TypeName)
		universe.go#L266: 		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/internal/gcimporter
		bexport.go#L211: 	case *types.TypeName:
		bimport.go#L230: 	case *types.TypeName:
		bimport.go#L442: 		if _, ok := obj.(*types.TypeName); !ok {
		bimport.go#L447: 		t0 := types.NewNamed(obj.(*types.TypeName), nil, nil)
		iexport.go#L483: 	case *types.TypeName:
		iexport.go#L667: func (w *exportWriter) qualifiedType(obj *types.TypeName) {
		iimport.go#L792: 		return pkg.Scope().Lookup(name).(*types.TypeName).Type()
		ureader_yes.go#L353: 		name := obj.(*types.TypeName)

	golang.org/x/tools/internal/typeparams
		typeparams_go118.go#L44: func NewTypeParam(name *types.TypeName, constraint types.Type) *TypeParam {