From bc0b98eeffa64f155e7f2a2dc6b883a97c4d0580 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 11 Nov 2021 22:21:48 -0800 Subject: [PATCH] cmd/compile/internal/types2: remove asNamed In the few remaining places where we use asNamed, if the argument is indeed a *Named, we either don't need to look "inside" it, or we call under() (which calls Named.underlying() which does resolve); so there's no need for an implicit resolution (which was done by asNamed). The only place where we do need to resolve is in lookup, so added the explicit resolve call in that case. Change-Id: Iff0a19fde7581e94149e89b9e48157c1981db105 Reviewed-on: https://go-review.googlesource.com/c/go/+/363441 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/decl.go | 2 +- src/cmd/compile/internal/types2/lookup.go | 7 ++++--- src/cmd/compile/internal/types2/type.go | 9 --------- src/cmd/compile/internal/types2/unify.go | 14 ++++++-------- src/cmd/compile/internal/types2/universe.go | 2 +- 5 files changed, 12 insertions(+), 22 deletions(-) diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index bab90fbd9a..d58fac5dbb 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -727,7 +727,7 @@ func (check *Checker) collectMethods(obj *TypeName) { // spec: "If the base type is a struct type, the non-blank method // and field names must be distinct." - base := asNamed(obj.typ) // shouldn't fail but be conservative + base, _ := obj.typ.(*Named) // shouldn't fail but be conservative if base != nil { u := base.under() if t, _ := u.(*Struct); t != nil { diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index cf6c6c7111..fbfe3c81ff 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -50,8 +50,8 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o // Thus, if we have a named pointer type, proceed with the underlying // pointer type but discard the result if it is a method since we would // not have found it for T (see also issue 8590). - if t := asNamed(T); t != nil { - if p, _ := safeUnderlying(t).(*Pointer); p != nil { + if t, _ := T.(*Named); t != nil { + if p, _ := t.Underlying().(*Pointer); p != nil { obj, index, indirect = lookupFieldOrMethod(p, false, false, pkg, name) if _, ok := obj.(*Func); ok { return nil, nil, false @@ -114,7 +114,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name // If we have a named type, we may have associated methods. // Look for those first. - if named := asNamed(typ); named != nil { + if named, _ := typ.(*Named); named != nil { if seen[named] { // We have seen this type before, at a more shallow depth // (note that multiples of this type at the current depth @@ -129,6 +129,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name seen[named] = true // look for a matching attached method + named.resolve(nil) if i, m := lookupMethodFold(named.methods, pkg, name, checkFold); m != nil { // potential match // caution: method may not have a proper signature yet diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go index 77dc7db896..3fea8d1776 100644 --- a/src/cmd/compile/internal/types2/type.go +++ b/src/cmd/compile/internal/types2/type.go @@ -87,12 +87,3 @@ func structuralType(typ Type) Type { } return nil } - -// If t is a defined type, asNamed returns that type (possibly after resolving it), otherwise it returns nil. -func asNamed(t Type) *Named { - e, _ := t.(*Named) - if e != nil { - e.resolve(nil) - } - return e -} diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go index 7f636c30d3..ccb6ee8709 100644 --- a/src/cmd/compile/internal/types2/unify.go +++ b/src/cmd/compile/internal/types2/unify.go @@ -235,14 +235,12 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool { // If exact unification is known to fail because we attempt to // match a type name against an unnamed type literal, consider // the underlying type of the named type. - // (Subtle: We use hasName to include any type with a name (incl. - // basic types and type parameters. We use asNamed because we only - // want *Named types.) - switch { - case !hasName(x) && y != nil && asNamed(y) != nil: - return u.nify(x, under(y), p) - case x != nil && asNamed(x) != nil && !hasName(y): - return u.nify(under(x), y, p) + // (We use !hasName to exclude any type with a name, including + // basic types and type parameters; the rest are unamed types.) + if nx, _ := x.(*Named); nx != nil && !hasName(y) { + return u.nify(nx.under(), y, p) + } else if ny, _ := y.(*Named); ny != nil && !hasName(x) { + return u.nify(x, ny.under(), p) } } diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go index 92fa32524c..fccab145f8 100644 --- a/src/cmd/compile/internal/types2/universe.go +++ b/src/cmd/compile/internal/types2/universe.go @@ -240,7 +240,7 @@ func def(obj Object) { return // nothing to do } // fix Obj link for named types - if typ := asNamed(obj.Type()); typ != nil { + if typ, _ := obj.Type().(*Named); typ != nil { typ.obj = obj.(*TypeName) } // exported identifiers go into package unsafe -- 2.50.0