go/ssa: types.Unalias() cleanup.

Removes a few instances of unneeded Unalias calls, and
adds additional documentation about aliases.

Change-Id: I02045ef74d6d9b80189caf6a9831bded2bae5ad4
Reviewed-on: https://go-review.googlesource.com/c/tools/+/568176
TryBot-Result: Gopher Robot <[email protected]>
Run-TryBot: Tim King <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Alan Donovan <[email protected]>

Author: timothy-king

go/ssa/builder.go

@@ -1253,7 +1253,7 @@ func (b *builder) compLit(fn *Function, addr Value, e *ast.CompositeLit, isZero
 	case *types.Array, *types.Slice:
 		var at *types.Array
 		var array Value
-		switch t := aliases.Unalias(t).(type) {
+		switch t := t.(type) {
 		case *types.Slice:
 			at = types.NewArray(t.Elem(), b.arrayLen(fn, e.Elts))
 			array = emitNew(fn, at, e.Lbrace, "slicelit")

go/ssa/const.go

@@ -46,9 +46,9 @@ func soleTypeKind(typ types.Type) types.BasicInfo {
 	// Candidates (perhaps all) are eliminated during the type-set
 	// iteration, which executes at least once.
 	state := types.IsBoolean | types.IsInteger | types.IsString
-	underIs(typeSetOf(typ), func(t types.Type) bool {
+	underIs(typeSetOf(typ), func(ut types.Type) bool {
 		var c types.BasicInfo
-		if t, ok := aliases.Unalias(t).(*types.Basic); ok {
+		if t, ok := ut.(*types.Basic); ok {
 			c = t.Info()
 		}
 		if c&types.IsNumeric != 0 { // int/float/complex

go/ssa/coretype.go

@@ -50,6 +50,7 @@ func typeSetOf(typ types.Type) termList {
 	// This is a adaptation of x/exp/typeparams.NormalTerms which x/tools cannot depend on.
 	var terms []*types.Term
 	var err error
+	// typeSetOf(t) == typeSetOf(Unalias(t))
 	switch typ := aliases.Unalias(typ).(type) {
 	case *types.TypeParam:
 		terms, err = typeparams.StructuralTerms(typ)

go/ssa/emit.go

@@ -12,7 +12,6 @@ import (
 	"go/token"
 	"go/types"
 
-	"golang.org/x/tools/internal/aliases"
 	"golang.org/x/tools/internal/typeparams"
 )
 
@@ -277,18 +276,20 @@ func emitConv(f *Function, val Value, typ types.Type) Value {
 		sliceTo0ArrayPtr
 		convert
 	)
-	classify := func(s, d types.Type) conversionCase {
+	// classify the conversion case of a source type us to a destination type ud.
+	// us and ud are underlying types (not *Named or *Alias)
+	classify := func(us, ud types.Type) conversionCase {
 		// Just a change of type, but not value or representation?
-		if isValuePreserving(s, d) {
+		if isValuePreserving(us, ud) {
 			return changeType
 		}
 
 		// Conversion from slice to array or slice to array pointer?
-		if slice, ok := aliases.Unalias(s).(*types.Slice); ok {
+		if slice, ok := us.(*types.Slice); ok {
 			var arr *types.Array
 			var ptr bool
 			// Conversion from slice to array pointer?
-			switch d := aliases.Unalias(d).(type) {
+			switch d := ud.(type) {
 			case *types.Array:
 				arr = d
 			case *types.Pointer:
@@ -313,8 +314,8 @@ func emitConv(f *Function, val Value, typ types.Type) Value {
 
 		// The only remaining case in well-typed code is a representation-
 		// changing conversion of basic types (possibly with []byte/[]rune).
-		if !isBasic(s) && !isBasic(d) {
-			panic(fmt.Sprintf("in %s: cannot convert term %s (%s [within %s]) to type %s [within %s]", f, val, val.Type(), s, typ, d))
+		if !isBasic(us) && !isBasic(ud) {
+			panic(fmt.Sprintf("in %s: cannot convert term %s (%s [within %s]) to type %s [within %s]", f, val, val.Type(), us, typ, ud))
 		}
 		return convert
 	}

go/ssa/func.go

@@ -37,7 +37,8 @@ func (f *Function) typeOf(e ast.Expr) types.Type {
 	panic(fmt.Sprintf("no type for %T @ %s", e, f.Prog.Fset.Position(e.Pos())))
 }
 
-// typ is the locally instantiated type of T. T==typ(T) if f is not an instantiation.
+// typ is the locally instantiated type of T.
+// If f is not an instantiation, then f.typ(T)==T.
 func (f *Function) typ(T types.Type) types.Type {
 	return f.subst.typ(T)
 }

go/ssa/interp/ops.go

@@ -173,7 +173,7 @@ func asUnsigned(x value) (value, bool) {
 
 // zero returns a new "zero" value of the specified type.
 func zero(t types.Type) value {
-	switch t := aliases.Unalias(t).(type) {
+	switch t := t.(type) {
 	case *types.Basic:
 		if t.Kind() == types.UntypedNil {
 			panic("untyped nil has no zero value")
@@ -235,6 +235,8 @@ func zero(t types.Type) value {
 		return a
 	case *types.Named:
 		return zero(t.Underlying())
+	case *aliases.Alias:
+		return zero(aliases.Unalias(t))
 	case *types.Interface:
 		return iface{} // nil type, methodset and value
 	case *types.Slice:

go/ssa/interp/reflect.go

@@ -179,8 +179,8 @@ func ext۰reflect۰Zero(fr *frame, args []value) value {
 }
 
 func reflectKind(t types.Type) reflect.Kind {
-	switch t := aliases.Unalias(t).(type) {
-	case *types.Named:
+	switch t := t.(type) {
+	case *types.Named, *aliases.Alias:
 		return reflectKind(t.Underlying())
 	case *types.Basic:
 		switch t.Kind() {

go/ssa/methods.go

@@ -210,7 +210,7 @@ func forEachReachable(msets *typeutil.MethodSetCache, T types.Type, f func(types
 
 		switch T := T.(type) {
 		case *aliases.Alias:
-			visit(aliases.Unalias(T), false)
+			visit(aliases.Unalias(T), skip) // emulates the pre-Alias behavior
 
 		case *types.Basic:
 			// nop

go/ssa/subst.go

@@ -80,11 +80,7 @@ func (subst *subster) typ(t types.Type) (res types.Type) {
 		subst.cache[t] = res
 	}()
 
-	// fall through if result r will be identical to t, types.Identical(r, t).
 	switch t := t.(type) {
-	case *aliases.Alias:
-		return subst.typ(aliases.Unalias(t))
-
 	case *types.TypeParam:
 		r := subst.replacements[t]
 		assert(r != nil, "type param without replacement encountered")
@@ -140,6 +136,9 @@ func (subst *subster) typ(t types.Type) (res types.Type) {
 	case *types.Interface:
 		return subst.interface_(t)
 
+	case *aliases.Alias:
+		return subst.alias(t)
+
 	case *types.Named:
 		return subst.named(t)
 
@@ -307,6 +306,18 @@ func (subst *subster) interface_(iface *types.Interface) *types.Interface {
 	return types.NewInterfaceType(methods, embeds).Complete()
 }
 
+func (subst *subster) alias(t *aliases.Alias) types.Type {
+	// TODO(go.dev/issues/46477): support TypeParameters once these are available from go/types.
+	u := aliases.Unalias(t)
+	if s := subst.typ(u); s != u {
+		// If there is any change, do not create a new alias.
+		return s
+	}
+	// If there is no change, t did not reach any type parameter.
+	// Keep the Alias.
+	return t
+}
+
 func (subst *subster) named(t *types.Named) types.Type {
 	// A named type may be:
 	// (1) ordinary named type (non-local scope, no type parameters, no type arguments),

go/ssa/util.go

@@ -51,8 +51,9 @@ func isNonTypeParamInterface(t types.Type) bool {
 }
 
 // isBasic reports whether t is a basic type.
+// t is assumed to be an Underlying type (not Named or Alias).
 func isBasic(t types.Type) bool {
-	_, ok := aliases.Unalias(t).(*types.Basic)
+	_, ok := t.(*types.Basic)
 	return ok
 }
 
@@ -263,13 +264,40 @@ func (c *canonizer) List(ts []types.Type) *typeList {
 		return nil
 	}
 
+	unaliasAll := func(ts []types.Type) []types.Type {
+		// Is there some top level alias?
+		var found bool
+		for _, t := range ts {
+			if _, ok := t.(*aliases.Alias); ok {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return ts // no top level alias
+		}
+
+		cp := make([]types.Type, len(ts)) // copy with top level aliases removed.
+		for i, t := range ts {
+			cp[i] = aliases.Unalias(t)
+		}
+		return cp
+	}
+	l := unaliasAll(ts)
+
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	return c.lists.rep(ts)
+	return c.lists.rep(l)
 }
 
 // Type returns a canonical representative of type T.
+// Removes top-level aliases.
+//
+// For performance, reasons the canonical instance is order-dependent,
+// and may contain deeply nested aliases.
 func (c *canonizer) Type(T types.Type) types.Type {
+	T = aliases.Unalias(T) // remove the top level alias.
+
 	c.mu.Lock()
 	defer c.mu.Unlock()