go/ssa: removing termList type

This is cleanup to remove the internal termList type.

Some additional minor refactoring so underIs takes a Type instead
of a list of terms.

Change-Id: I934b16bbf94f1d62762a5622a85ceea22f1c2108
Reviewed-on: https://go-review.googlesource.com/c/tools/+/641835
Auto-Submit: Tim King <taking@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Alan Donovan <adonovan@google.com>

Author: timothy-king

go/ssa/builder.go

@@ -856,7 +856,7 @@ func (b *builder) expr0(fn *Function, e ast.Expr, tv types.TypeAndValue) Value {
 				if recv, ok := types.Unalias(sel.recv).(*types.TypeParam); ok {
 					// Emit a nil check if any possible instantiation of the
 					// type parameter is an interface type.
-					if typeSetOf(recv).Len() > 0 {
+					if len(typeSetOf(recv)) > 0 {
 						// recv has a concrete term its typeset.
 						// So it cannot be instantiated as an interface.
 						//

go/ssa/const.go

@@ -45,7 +45,7 @@ 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(ut types.Type) bool {
+	underIs(typ, func(ut types.Type) bool {
 		var c types.BasicInfo
 		if t, ok := ut.(*types.Basic); ok {
 			c = t.Info()
@@ -126,7 +126,7 @@ func (c *Const) IsNil() bool {
 // nillable reports whether *new(T) == nil is legal for type T.
 func nillable(t types.Type) bool {
 	if typeparams.IsTypeParam(t) {
-		return underIs(typeSetOf(t), func(u types.Type) bool {
+		return underIs(t, func(u types.Type) bool {
 			// empty type set (u==nil) => any underlying types => not nillable
 			return u != nil && nillable(u)
 		})

go/ssa/coretype.go

@@ -22,30 +22,24 @@ func isBytestring(T types.Type) bool {
 		return false
 	}
 
-	tset := typeSetOf(U)
-	if tset.Len() != 2 {
-		return false
-	}
 	hasBytes, hasString := false, false
-	underIs(tset, func(t types.Type) bool {
+	ok := underIs(U, func(t types.Type) bool {
 		switch {
 		case isString(t):
 			hasString = true
+			return true
 		case isByteSlice(t):
 			hasBytes = true
+			return true
+		default:
+			return false
 		}
-		return hasBytes || hasString
 	})
-	return hasBytes && hasString
+	return ok && hasBytes && hasString
 }
 
-// termList is a list of types.
-type termList []*types.Term            // type terms of the type set
-func (s termList) Len() int            { return len(s) }
-func (s termList) At(i int) types.Type { return s[i].Type() }
-
-// typeSetOf returns the type set of typ. Returns an empty typeset on an error.
-func typeSetOf(typ types.Type) termList {
+// typeSetOf returns the type set of typ as a normalized term set. Returns an empty set on an error.
+func typeSetOf(typ types.Type) []*types.Term {
 	// This is a adaptation of x/exp/typeparams.NormalTerms which x/tools cannot depend on.
 	var terms []*types.Term
 	var err error
@@ -65,20 +59,21 @@ func typeSetOf(typ types.Type) termList {
 	}
 
 	if err != nil {
-		return termList(nil)
+		return nil
 	}
-	return termList(terms)
+	return terms
 }
 
-// underIs calls f with the underlying types of the specific type terms
-// of s and reports whether all calls to f returned true. If there are
-// no specific terms, underIs returns the result of f(nil).
-func underIs(s termList, f func(types.Type) bool) bool {
-	if s.Len() == 0 {
+// underIs calls f with the underlying types of the type terms
+// of the type set of typ and reports whether all calls to f returned true.
+// If there are no specific terms, underIs returns the result of f(nil).
+func underIs(typ types.Type, f func(types.Type) bool) bool {
+	s := typeSetOf(typ)
+	if len(s) == 0 {
 		return f(nil)
 	}
-	for i := 0; i < s.Len(); i++ {
-		u := s.At(i).Underlying()
+	for _, t := range s {
+		u := t.Type().Underlying()
 		if !f(u) {
 			return false
 		}
@@ -87,7 +82,7 @@ func underIs(s termList, f func(types.Type) bool) bool {
 }
 
 // indexType returns the element type and index mode of a IndexExpr over a type.
-// It returns (nil, invalid) if the type is not indexable; this should never occur in a well-typed program.
+// It returns an invalid mode if the type is not indexable; this should never occur in a well-typed program.
 func indexType(typ types.Type) (types.Type, indexMode) {
 	switch U := typ.Underlying().(type) {
 	case *types.Array:
@@ -104,22 +99,22 @@ func indexType(typ types.Type) (types.Type, indexMode) {
 		return tByte, ixValue // must be a string
 	case *types.Interface:
 		tset := typeSetOf(U)
-		if tset.Len() == 0 {
+		if len(tset) == 0 {
 			return nil, ixInvalid // no underlying terms or error is empty.
 		}
-
-		elem, mode := indexType(tset.At(0))
-		for i := 1; i < tset.Len() && mode != ixInvalid; i++ {
-			e, m := indexType(tset.At(i))
+		elem, mode := indexType(tset[0].Type())
+		for _, t := range tset[1:] {
+			e, m := indexType(t.Type())
 			if !types.Identical(elem, e) { // if type checked, just a sanity check
 				return nil, ixInvalid
 			}
 			// Update the mode to the most constrained address type.
 			mode = mode.meet(m)
+			if mode == ixInvalid {
+				return nil, ixInvalid // fast exit
+			}
 		}
-		if mode != ixInvalid {
-			return elem, mode
-		}
+		return elem, mode
 	}
 	return nil, ixInvalid
 }

go/ssa/sanity.go

@@ -142,8 +142,8 @@ func (s *sanity) checkInstr(idx int, instr Instruction) {
 	case *ChangeType:
 	case *SliceToArrayPointer:
 	case *Convert:
-		if from := instr.X.Type(); !isBasicConvTypes(typeSetOf(from)) {
-			if to := instr.Type(); !isBasicConvTypes(typeSetOf(to)) {
+		if from := instr.X.Type(); !isBasicConvTypes(from) {
+			if to := instr.Type(); !isBasicConvTypes(to) {
 				s.errorf("convert %s -> %s: at least one type must be basic (or all basic, []byte, or []rune)", from, to)
 			}
 		}

go/ssa/util.go

@@ -85,21 +85,22 @@ func isRuneSlice(t types.Type) bool {
 	return false
 }
 
-// isBasicConvTypes returns true when a type set can be
-// one side of a Convert operation. This is when:
+// isBasicConvTypes returns true when the type set of a type
+// can be one side of a Convert operation. This is when:
 // - All are basic, []byte, or []rune.
 // - At least 1 is basic.
 // - At most 1 is []byte or []rune.
-func isBasicConvTypes(tset termList) bool {
-	basics := 0
-	all := underIs(tset, func(t types.Type) bool {
+func isBasicConvTypes(typ types.Type) bool {
+	basics, cnt := 0, 0
+	ok := underIs(typ, func(t types.Type) bool {
+		cnt++
 		if isBasic(t) {
 			basics++
 			return true
 		}
 		return isByteSlice(t) || isRuneSlice(t)
 	})
-	return all && basics >= 1 && tset.Len()-basics <= 1
+	return ok && basics >= 1 && cnt-basics <= 1
 }
 
 // isPointer reports whether t's underlying type is a pointer.