From 2d250043b4c5095f326ab72741d557fe74e4e3a6 Mon Sep 17 00:00:00 2001 From: Rob Findley Date: Wed, 11 Aug 2021 13:36:26 -0400 Subject: [PATCH] cmd/compile/internal/types2: simplify Named.under Remove some unnecessary logic from Named.under: - no need to have special handling for Typ[Invalid]: this is the same as other cases where the underlying type is resolved. - use Underlying() to get the loaded and expanded underlying - no need for special handling of the first iteration Change-Id: I2029711f51fa9eaaee11debadd55974a1376a980 Reviewed-on: https://go-review.googlesource.com/c/go/+/341857 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/types2/named.go | 52 +++++++++--------------- 1 file changed, 19 insertions(+), 33 deletions(-) diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go index b12e59b586..5967172675 100644 --- a/src/cmd/compile/internal/types2/named.go +++ b/src/cmd/compile/internal/types2/named.go @@ -166,18 +166,13 @@ func (t *Named) String() string { return TypeString(t, nil) } // is detected, the result is Typ[Invalid]. If a cycle is detected and // n0.check != nil, the cycle is reported. func (n0 *Named) under() Type { - n0.expand(nil) - - u := n0.load().underlying - - if u == Typ[Invalid] { - return u - } + u := n0.Underlying() // If the underlying type of a defined type is not a defined // (incl. instance) type, then that is the desired underlying // type. - switch u.(type) { + var n1 *Named + switch u1 := u.(type) { case nil: return Typ[Invalid] default: @@ -185,6 +180,7 @@ func (n0 *Named) under() Type { return u case *Named: // handled below + n1 = u1 } if n0.check == nil { @@ -194,43 +190,33 @@ func (n0 *Named) under() Type { // Invariant: after this point n0 as well as any named types in its // underlying chain should be set up when this function exits. check := n0.check + n := n0 - // If we can't expand u at this point, it is invalid. - n := asNamed(u) - if n == nil { - n0.underlying = Typ[Invalid] - return n0.underlying - } + seen := make(map[*Named]int) // types that need their underlying resolved + var path []Object // objects encountered, for cycle reporting - // Otherwise, follow the forward chain. - seen := map[*Named]int{n0: 0} - path := []Object{n0.obj} +loop: for { - u = n.load().underlying - if u == nil { - u = Typ[Invalid] - break - } - var n1 *Named - switch u1 := u.(type) { - case *Named: - u1.expand(nil) - n1 = u1 - } - if n1 == nil { - break // end of chain - } - seen[n] = len(seen) path = append(path, n.obj) n = n1 - if i, ok := seen[n]; ok { // cycle check.cycleError(path[i:]) u = Typ[Invalid] break } + u = n.Underlying() + switch u1 := u.(type) { + case nil: + u = Typ[Invalid] + break loop + default: + break loop + case *Named: + // Continue collecting *Named types in the chain. + n1 = u1 + } } for n := range seen {