cmd/compile: call types2.Unalias to be ready for GODEBUG=gotypesalias=1

types2.Unalias is not needed if we know we have a core or underlying
type. Also, types of declared functions (signatures) cannot be aliases
(this includes tuples).

Fixes #65125.

Change-Id: I1faa26b66f6c646719e830dd661136fae86f3775
Reviewed-on: https://go-review.googlesource.com/c/go/+/556036
Run-TryBot: Robert Griesemer <gri@google.com>
Reviewed-by: Mauri de Souza Meneguzzo <mauri870@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Auto-Submit: Robert Griesemer <gri@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index f9e3838fd955e980dc11d847d81935a3d8f1a1b1..0bff71e65845efc0a158fceb3d35642b3de0341a 100644 (file)
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -80,7 +80,7 @@ func idealType(tv syntax.TypeAndValue) types2.Type {
        // types2 mostly satisfies this expectation already. But there are a few
        // cases where the Go spec doesn't require converting to concrete type,
        // and so types2 leaves them untyped. So we need to fix those up here.
-       typ := tv.Type
+       typ := types2.Unalias(tv.Type)
        if basic, ok := typ.(*types2.Basic); ok && basic.Info()&types2.IsUntyped != 0 {
                switch basic.Kind() {
                case types2.UntypedNil:
@@ -109,13 +109,14 @@ func idealType(tv syntax.TypeAndValue) types2.Type {
 }
 
 func isTypeParam(t types2.Type) bool {
-       _, ok := t.(*types2.TypeParam)
+       _, ok := types2.Unalias(t).(*types2.TypeParam)
        return ok
 }
 
 // isNotInHeap reports whether typ is or contains an element of type
 // runtime/internal/sys.NotInHeap.
 func isNotInHeap(typ types2.Type) bool {
+       typ = types2.Unalias(typ)
        if named, ok := typ.(*types2.Named); ok {
                if obj := named.Obj(); obj.Name() == "nih" && obj.Pkg().Path() == "runtime/internal/sys" {
                        return true

diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go
index d909f3467bf08d57b1e030cdb28d073243d591bc..e0b7bb946d28fd88471401602c6b37cb60148be9 100644 (file)
--- a/src/cmd/compile/internal/noder/irgen.go
+++ b/src/cmd/compile/internal/noder/irgen.go
@@ -97,7 +97,7 @@ func checkFiles(m posMap, noders []*noder) (*types2.Package, *types2.Info) {
        for _, file := range files {
                syntax.Inspect(file, func(n syntax.Node) bool {
                        if n, ok := n.(*syntax.InterfaceType); ok {
-                               if f.hasCycle(n.GetTypeInfo().Type.(*types2.Interface)) {
+                               if f.hasCycle(types2.Unalias(n.GetTypeInfo().Type).(*types2.Interface)) {
                                        base.ErrorfAt(m.makeXPos(n.Pos()), errors.InvalidTypeCycle, "invalid recursive type: anonymous interface refers to itself (see https://go.dev/issue/56103)")
 
                                        for typ := range f.cyclic {
@@ -171,7 +171,7 @@ func (f *cycleFinder) hasCycle(typ *types2.Interface) bool {
 // visit recursively walks typ0 to check any referenced interface types.
 func (f *cycleFinder) visit(typ0 types2.Type) bool {
        for { // loop for tail recursion
-               switch typ := typ0.(type) {
+               switch typ := types2.Unalias(typ0).(type) {
                default:
                        base.Fatalf("unexpected type: %T", typ)
 

diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go
index 46d5213694b0a09cbcf8a467c8f979f76c6dad8d..e5894c950543ae091e6b934196ffe562a6c43b7a 100644 (file)
--- a/src/cmd/compile/internal/noder/writer.go
+++ b/src/cmd/compile/internal/noder/writer.go
@@ -217,7 +217,7 @@ type itabInfo struct {
 // generic function or method.
 func (dict *writerDict) typeParamIndex(typ *types2.TypeParam) int {
        for idx, implicit := range dict.implicits {
-               if implicit.Type().(*types2.TypeParam) == typ {
+               if types2.Unalias(implicit.Type()).(*types2.TypeParam) == typ {
                        return idx
                }
        }
@@ -498,7 +498,7 @@ func (pw *pkgWriter) typIdx(typ types2.Type, dict *writerDict) typeInfo {
        w := pw.newWriter(pkgbits.RelocType, pkgbits.SyncTypeIdx)
        w.dict = dict
 
-       switch typ := typ.(type) {
+       switch typ := types2.Unalias(typ).(type) {
        default:
                base.Fatalf("unexpected type: %v (%T)", typ, typ)
 
@@ -889,7 +889,7 @@ func (w *writer) objDict(obj types2.Object, dict *writerDict) {
        // parameter is constrained to `int | uint` but then never used in
        // arithmetic/conversions/etc, we could shape those together.
        for _, implicit := range dict.implicits {
-               tparam := implicit.Type().(*types2.TypeParam)
+               tparam := types2.Unalias(implicit.Type()).(*types2.TypeParam)
                w.Bool(tparam.Underlying().(*types2.Interface).IsMethodSet())
        }
        for i := 0; i < ntparams; i++ {
@@ -2124,7 +2124,7 @@ func (w *writer) methodExpr(expr *syntax.SelectorExpr, recv types2.Type, sel *ty
 
        // Method on a type parameter. These require an indirect call
        // through the current function's runtime dictionary.
-       if typeParam, ok := recv.(*types2.TypeParam); w.Bool(ok) {
+       if typeParam, ok := types2.Unalias(recv).(*types2.TypeParam); w.Bool(ok) {
                typeParamIdx := w.dict.typeParamIndex(typeParam)
                methodInfo := w.p.selectorIdx(fun)
 
@@ -2137,7 +2137,7 @@ func (w *writer) methodExpr(expr *syntax.SelectorExpr, recv types2.Type, sel *ty
        }
 
        if !isInterface(recv) {
-               if named, ok := deref2(recv).(*types2.Named); ok {
+               if named, ok := types2.Unalias(deref2(recv)).(*types2.Named); ok {
                        obj, targs := splitNamed(named)
                        info := w.p.objInstIdx(obj, targs, w.dict)
 
@@ -2363,7 +2363,7 @@ func (w *writer) varDictIndex(obj *types2.Var) {
 }
 
 func isUntyped(typ types2.Type) bool {
-       basic, ok := typ.(*types2.Basic)
+       basic, ok := types2.Unalias(typ).(*types2.Basic)
        return ok && basic.Info()&types2.IsUntyped != 0
 }
 
@@ -2416,7 +2416,7 @@ func (w *writer) exprType(iface types2.Type, typ syntax.Expr) {
 // If typ is a type parameter, then isInterface reports an internal
 // compiler error instead.
 func isInterface(typ types2.Type) bool {
-       if _, ok := typ.(*types2.TypeParam); ok {
+       if _, ok := types2.Unalias(typ).(*types2.TypeParam); ok {
                // typ is a type parameter and may be instantiated as either a
                // concrete or interface type, so the writer can't depend on
                // knowing this.
@@ -2867,7 +2867,7 @@ func (pw *pkgWriter) isBuiltin(expr syntax.Expr, builtin string) bool {
 
 // recvBase returns the base type for the given receiver parameter.
 func recvBase(recv *types2.Var) *types2.Named {
-       typ := recv.Type()
+       typ := types2.Unalias(recv.Type())
        if ptr, ok := typ.(*types2.Pointer); ok {
                typ = ptr.Elem()
        }
@@ -2945,7 +2945,7 @@ func asWasmImport(p syntax.Pragma) *WasmImport {
 
 // isPtrTo reports whether from is the type *to.
 func isPtrTo(from, to types2.Type) bool {
-       ptr, ok := from.(*types2.Pointer)
+       ptr, ok := types2.Unalias(from).(*types2.Pointer)
        return ok && types2.Identical(ptr.Elem(), to)
 }