cmd/compile/internal/types: remove TTYPEPARAM and TUNION types

These were used by the nounified frontend for representing
uninstantiated generic types; however, the unified frontend only needs
types1 to represent instantiated types.

Updates #57410.

Change-Id: Iac417fbf2b86f4e08bd7fdd26ae8ed17395ce833
Reviewed-on: https://go-review.googlesource.com/c/go/+/458621
Run-TryBot: Matthew Dempsky <[email protected]>
Reviewed-by: Keith Randall <[email protected]>
Reviewed-by: Keith Randall <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: mdempsky

src/cmd/compile/internal/noder/helpers.go

@@ -61,9 +61,7 @@ func FixValue(typ *types.Type, val constant.Value) constant.Value {
 	if !typ.IsUntyped() {
 		val = typecheck.DefaultLit(ir.NewBasicLit(src.NoXPos, val), typ).Val()
 	}
-	if !typ.IsTypeParam() {
-		ir.AssertValidTypeForConst(typ, val)
-	}
+	ir.AssertValidTypeForConst(typ, val)
 	return val
 }
 
@@ -211,15 +209,7 @@ var one = constant.MakeInt64(1)
 func IncDec(pos src.XPos, op ir.Op, x ir.Node) *ir.AssignOpStmt {
 	assert(x.Type() != nil)
 	bl := ir.NewBasicLit(pos, one)
-	if x.Type().HasTParam() {
-		// If the operand is generic, then types2 will have proved it must be
-		// a type that fits with increment/decrement, so just set the type of
-		// "one" to n.Type(). This works even for types that are eventually
-		// float or complex.
-		typed(x.Type(), bl)
-	} else {
-		bl = typecheck.DefaultLit(bl, x.Type())
-	}
+	bl = typecheck.DefaultLit(bl, x.Type())
 	return ir.NewAssignOpStmt(pos, op, x, bl)
 }
 

src/cmd/compile/internal/reflectdata/reflect.go

@@ -959,7 +959,7 @@ func formalType(t *types.Type) *types.Type {
 
 func writeType(t *types.Type) *obj.LSym {
 	t = formalType(t)
-	if t.IsUntyped() || t.HasTParam() {
+	if t.IsUntyped() {
 		base.Fatalf("writeType %v", t)
 	}
 
@@ -1260,11 +1260,6 @@ func InterfaceMethodOffset(ityp *types.Type, i int64) int64 {
 
 // NeedRuntimeType ensures that a runtime type descriptor is emitted for t.
 func NeedRuntimeType(t *types.Type) {
-	if t.HasTParam() {
-		// Generic types don't really exist at run-time and have no runtime
-		// type descriptor.  But we do write out shape types.
-		return
-	}
 	if _, ok := signatset[t]; !ok {
 		signatset[t] = struct{}{}
 		signatslice = append(signatslice, typeAndStr{t: t, short: types.TypeSymName(t), regular: t.String()})
@@ -1781,9 +1776,6 @@ func CollectPTabs() {
 		if s.Pkg.Name != "main" {
 			continue
 		}
-		if n.Type().HasTParam() {
-			continue // skip generic functions (#52937)
-		}
 		ptabs = append(ptabs, n)
 	}
 }

src/cmd/compile/internal/typecheck/dcl.go

@@ -305,12 +305,6 @@ func autotmpname(n int) string {
 // f is method type, with receiver.
 // return function type, receiver as first argument (or not).
 func NewMethodType(sig *types.Type, recv *types.Type) *types.Type {
-	if sig.HasTParam() {
-		base.Fatalf("NewMethodType with type parameters in signature %+v", sig)
-	}
-	if recv != nil && recv.HasTParam() {
-		base.Fatalf("NewMethodType with type parameters in receiver %+v", recv)
-	}
 	nrecvs := 0
 	if recv != nil {
 		nrecvs++

src/cmd/compile/internal/typecheck/subr.go

@@ -730,19 +730,7 @@ func implements(t, iface *types.Type, m, samename **types.Field, ptr *int) bool
 		return false
 	}
 
-	if t.IsInterface() || t.IsTypeParam() {
-		if t.IsTypeParam() {
-			// If t is a simple type parameter T, its type and underlying is the same.
-			// If t is a type definition:'type P[T any] T', its type is P[T] and its
-			// underlying is T. Therefore we use 't.Underlying() != t' to distinguish them.
-			if t.Underlying() != t {
-				CalcMethods(t)
-			} else {
-				// A typeparam satisfies an interface if its type bound
-				// has all the methods of that interface.
-				t = t.Bound()
-			}
-		}
+	if t.IsInterface() {
 		i := 0
 		tms := t.AllMethods().Slice()
 		for _, im := range iface.AllMethods().Slice() {

src/cmd/compile/internal/types/fmt.go

@@ -571,27 +571,6 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 	case TUNSAFEPTR:
 		b.WriteString("unsafe.Pointer")
 
-	case TTYPEPARAM:
-		if t.Sym() != nil {
-			sconv2(b, t.Sym(), 'v', mode)
-		} else {
-			b.WriteString("tp")
-			// Print out the pointer value for now to disambiguate type params
-			fmt.Fprintf(b, "%p", t)
-		}
-
-	case TUNION:
-		for i := 0; i < t.NumTerms(); i++ {
-			if i > 0 {
-				b.WriteString("|")
-			}
-			elem, tilde := t.Term(i)
-			if tilde {
-				b.WriteString("~")
-			}
-			tconv2(b, elem, 0, mode, visited)
-		}
-
 	case Txxx:
 		b.WriteString("Txxx")
 

src/cmd/compile/internal/types/kind_string.go

@@ -123,10 +123,6 @@ func expandiface(t *Type) {
 			continue
 		}
 
-		if m.Type.IsUnion() {
-			continue
-		}
-
 		// In 1.18, embedded types can be anything. In Go 1.17, we disallow
 		// embedding anything other than interfaces. This requirement was caught
 		// by types2 already, so allow non-interface here.
@@ -343,12 +339,6 @@ func CalcSize(t *Type) {
 		t.align = uint8(PtrSize)
 		expandiface(t)
 
-	case TUNION:
-		// Always part of an interface for now, so size/align don't matter.
-		// Pretend a union is represented like an interface.
-		w = 2 * int64(PtrSize)
-		t.align = uint8(PtrSize)
-
 	case TCHAN: // implemented as pointer
 		w = int64(PtrSize)
 
@@ -445,11 +435,6 @@ func CalcSize(t *Type) {
 			base.Warn("bad type %v %d\n", t1, w)
 		}
 		t.align = 1
-
-	case TTYPEPARAM:
-		// TODO(danscales) - remove when we eliminate the need
-		// to do CalcSize in noder2 (which shouldn't be needed in the noder)
-		w = int64(PtrSize)
 	}
 
 	if PtrSize == 4 && w != int64(int32(w)) {