[dev.typeparams] cmd/compile/internal/types2: move methods on *Named into named.go...

No other code changes except for an additional comment.

Change-Id: Ica3cea446c6c88f4f81a86d77b289a0b54b1e76f
Reviewed-on: https://go-review.googlesource.com/c/go/+/333671
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 4f91bc70c78564f045c819b8e5d85631214ee95e..9fb9815f4dbf1340eae028557d0d08c12faf08b1 100644 (file)
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -515,102 +515,6 @@ func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init syntax.Expr) {
        check.initVars(lhs, []syntax.Expr{init}, nopos)
 }
 
-// under returns the expanded underlying type of n0; possibly by following
-// forward chains of named types. If an underlying type is found, resolve
-// the chain by setting the underlying type for each defined type in the
-// chain before returning it. If no underlying type is found or a cycle
-// 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 {
-       u := n0.Underlying()
-
-       if u == Typ[Invalid] {
-               return u
-       }
-
-       // 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) {
-       case nil:
-               return Typ[Invalid]
-       default:
-               // common case
-               return u
-       case *Named, *instance:
-               // handled below
-       }
-
-       if n0.check == nil {
-               panic("internal error: Named.check == nil but type is incomplete")
-       }
-
-       // 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
-
-       // 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
-       }
-
-       // Otherwise, follow the forward chain.
-       seen := map[*Named]int{n0: 0}
-       path := []Object{n0.obj}
-       for {
-               u = n.Underlying()
-               if u == nil {
-                       u = Typ[Invalid]
-                       break
-               }
-               var n1 *Named
-               switch u1 := u.(type) {
-               case *Named:
-                       n1 = u1
-               case *instance:
-                       n1, _ = u1.expand().(*Named)
-                       if n1 == nil {
-                               u = Typ[Invalid]
-                       }
-               }
-               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
-               }
-       }
-
-       for n := range seen {
-               // We should never have to update the underlying type of an imported type;
-               // those underlying types should have been resolved during the import.
-               // Also, doing so would lead to a race condition (was issue #31749).
-               // Do this check always, not just in debug mode (it's cheap).
-               if n.obj.pkg != check.pkg {
-                       panic("internal error: imported type with unresolved underlying type")
-               }
-               n.underlying = u
-       }
-
-       return u
-}
-
-func (n *Named) setUnderlying(typ Type) {
-       if n != nil {
-               n.underlying = typ
-       }
-}
-
 func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named) {
        assert(obj.typ == nil)
 

diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go
index 2005dfbd84a4386cb7b3a8607dacba47a63b079b..da098b58b7aba0fc65e9f43573dc261c7cda9d9f 100644 (file)
--- a/src/cmd/compile/internal/types2/named.go
+++ b/src/cmd/compile/internal/types2/named.go
@@ -142,3 +142,102 @@ func (t *Named) AddMethod(m *Func) {
 
 func (t *Named) Underlying() Type { return t.expand().underlying }
 func (t *Named) String() string   { return TypeString(t, nil) }
+
+// ----------------------------------------------------------------------------
+// Implementation
+
+// under returns the expanded underlying type of n0; possibly by following
+// forward chains of named types. If an underlying type is found, resolve
+// the chain by setting the underlying type for each defined type in the
+// chain before returning it. If no underlying type is found or a cycle
+// 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 {
+       u := n0.Underlying()
+
+       if u == Typ[Invalid] {
+               return u
+       }
+
+       // 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) {
+       case nil:
+               return Typ[Invalid]
+       default:
+               // common case
+               return u
+       case *Named, *instance:
+               // handled below
+       }
+
+       if n0.check == nil {
+               panic("internal error: Named.check == nil but type is incomplete")
+       }
+
+       // 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
+
+       // 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
+       }
+
+       // Otherwise, follow the forward chain.
+       seen := map[*Named]int{n0: 0}
+       path := []Object{n0.obj}
+       for {
+               u = n.Underlying()
+               if u == nil {
+                       u = Typ[Invalid]
+                       break
+               }
+               var n1 *Named
+               switch u1 := u.(type) {
+               case *Named:
+                       n1 = u1
+               case *instance:
+                       n1, _ = u1.expand().(*Named)
+                       if n1 == nil {
+                               u = Typ[Invalid]
+                       }
+               }
+               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
+               }
+       }
+
+       for n := range seen {
+               // We should never have to update the underlying type of an imported type;
+               // those underlying types should have been resolved during the import.
+               // Also, doing so would lead to a race condition (was issue #31749).
+               // Do this check always, not just in debug mode (it's cheap).
+               if n.obj.pkg != check.pkg {
+                       panic("internal error: imported type with unresolved underlying type")
+               }
+               n.underlying = u
+       }
+
+       return u
+}
+
+func (n *Named) setUnderlying(typ Type) {
+       if n != nil {
+               n.underlying = typ
+       }
+}