go/types, types2: simplify unifier

The unifier was written such that it was possible to specify
a different set of type parameters (declared by different
generic declarations) for each type x, y being unified,
to allow for what is called "bidirectional unification"
in the documentation (comments).

However, in the current implementation, this mechanism is
not used:

- For function type inference, we only consider the
type parameter list of the generic function (type parameters
that appear in the arguments are considered stand-alone types).
We use type parameter renaming to avoid any problems in case
of recursive generic calls that rely on type inference.

- For constraint type inference, the type parameters for the
types x and y (i.e., the type parameter and its constraint)
are the same and had to be explicitly set to be identical.

This CL removes the ability to set separate type parameter
lists. Instead a single type parameter list is used during
unification and is provided when we initialize a unifier.

As a consequence, we don't need to maintain the separate
tparamsList data structure: since we have a single list
of type parameters we can keep it directly in the unifier.

Adjust all the unifier code accordingly and update comments.

As an aside, remove the `exact` flag from the unifier as it
was never set. However, keep the functionality for now and
use a constant (exactUnification) instead. This makes it
easy to find the respectice code without incurring any cost.

Change-Id: I969ba6dbbed2d65d06ba4e20b97bdc362c806772
Reviewed-on: https://go-review.googlesource.com/c/go/+/463223
Reviewed-by: Robert Griesemer <[email protected]>
Run-TryBot: Robert Griesemer <[email protected]>
Reviewed-by: Robert Findley <[email protected]>
Auto-Submit: Robert Griesemer <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>

Author: griesemer

src/cmd/compile/internal/types2/infer.go

@@ -135,19 +135,18 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type,
 	// Unify parameter and argument types for generic parameters with typed arguments
 	// and collect the indices of generic parameters with untyped arguments.
 	// Terminology: generic parameter = function parameter with a type-parameterized type
-	u := newUnifier(false)
-	u.x.init(tparams)
+	u := newUnifier(tparams)
 
 	// Set the type arguments which we know already.
 	for i, targ := range targs {
 		if targ != nil {
-			u.x.set(i, targ)
+			u.set(i, targ)
 		}
 	}
 
 	errorf := func(kind string, tpar, targ Type, arg *operand) {
 		// provide a better error message if we can
-		targs, index := u.x.types()
+		targs, index := u.inferred()
 		if index == 0 {
 			// The first type parameter couldn't be inferred.
 			// If none of them could be inferred, don't try
@@ -213,7 +212,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type,
 
 	// If we've got all type arguments, we're done.
 	var index int
-	targs, index = u.x.types()
+	targs, index = u.inferred()
 	if index < 0 {
 		return targs
 	}
@@ -249,7 +248,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type,
 	}
 
 	// If we've got all type arguments, we're done.
-	targs, index = u.x.types()
+	targs, index = u.inferred()
 	if index < 0 {
 		return targs
 	}
@@ -462,16 +461,13 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type,
 		}()
 	}
 
-	// Setup bidirectional unification between constraints
-	// and the corresponding type arguments (which may be nil!).
-	u := newUnifier(false)
-	u.x.init(tparams)
-	u.y = u.x // type parameters between LHS and RHS of unification are identical
+	// Unify type parameters with their constraints.
+	u := newUnifier(tparams)
 
 	// Set the type arguments which we know already.
 	for i, targ := range targs {
 		if targ != nil {
-			u.x.set(i, targ)
+			u.set(i, targ)
 		}
 	}
 
@@ -490,7 +486,7 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type,
 	// here could handle the respective type parameters only,
 	// but that will come at a cost of extra complexity which
 	// may not be worth it.)
-	for n := u.x.unknowns(); n > 0; {
+	for n := u.unknowns(); n > 0; {
 		nn := n
 
 		for i, tpar := range tparams {
@@ -501,7 +497,7 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type,
 					u.tracef("core(%s) = %s (single = %v)", tpar, core, single)
 				}
 				// A type parameter can be unified with its core type in two cases.
-				tx := u.x.at(i)
+				tx := u.at(i)
 				switch {
 				case tx != nil:
 					// The corresponding type argument tx is known.
@@ -534,15 +530,15 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type,
 					// The corresponding type argument tx is unknown and there's a single
 					// specific type and no tilde.
 					// In this case the type argument must be that single type; set it.
-					u.x.set(i, core.typ)
+					u.set(i, core.typ)
 
 				default:
 					// Unification is not possible and no progress was made.
 					continue
 				}
 
 				// The number of known type arguments may have changed.
-				nn = u.x.unknowns()
+				nn = u.unknowns()
 				if nn == 0 {
 					break // all type arguments are known
 				}
@@ -560,14 +556,14 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type,
 		n = nn
 	}
 
-	// u.x.types() now contains the incoming type arguments plus any additional type
+	// u.inferred() now contains the incoming type arguments plus any additional type
 	// arguments which were inferred from core terms. The newly inferred non-nil
 	// entries may still contain references to other type parameters.
 	// For instance, for [A any, B interface{ []C }, C interface{ *A }], if A == int
 	// was given, unification produced the type list [int, []C, *A]. We eliminate the
 	// remaining type parameters by substituting the type parameters in this type list
 	// until nothing changes anymore.
-	types, _ = u.x.types()
+	types, _ = u.inferred()
 	if debug {
 		for i, targ := range targs {
 			assert(targ == nil || types[i] == targ)