[release-branch.go1.18] go/types, types2: fix overlap test for union termlist

Per the spec, "the type sets of all non-interface terms must be
pairwise disjoint (the pairwise intersection of the type sets must
be empty)" in a union.

For the overlap test, the existing implementation casually mixed
syntactic union terms (which may have interface type) with type set
terms (which are normalized/expanded and must not have interface
type). As a consequence, in some cases the overlap test failed.

This change skips terms with interface types in the overlap test.

For this cherry-pick, also rename the files ending in issue51607.go
to issue51607.go2 because the 1.18 branch requires tests containing
generic features to end in .go2.

Fixes #52119.

Change-Id: I8ae9953db31f0a0428389c6a45a6696aa2450219
Reviewed-on: https://go-review.googlesource.com/c/go/+/397695
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/398154

5 files changed, 87 insertions, 12 deletions

diff --git a/src/cmd/compile/internal/types2/testdata/examples/constraints.go2 b/src/cmd/compile/internal/types2/testdata/examples/constraints.go2
index 4d7f70313a..0d3e282529 100644
--- a/src/cmd/compile/internal/types2/testdata/examples/constraints.go2
+++ b/src/cmd/compile/internal/types2/testdata/examples/constraints.go2
@@ -24,7 +24,8 @@ type (
 	_ interface{int|any}
 	_ interface{int|~string|union}
 	_ interface{int|~string|interface{int}}
-	_ interface{union|union /* ERROR overlapping terms p.union and p.union */ }
+	_ interface{union|int}   // interfaces (here: union) are ignored when checking for overlap
+	_ interface{union|union} // ditto
 
 	// For now we do not permit interfaces with methods in unions.
 	_ interface{~ /* ERROR invalid use of ~ */ any}
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue51607.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue51607.go2
new file mode 100644
index 0000000000..d8df143627
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue51607.go2
@@ -0,0 +1,65 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package p
+
+// Interface types must be ignored during overlap test.
+
+type (
+	T1 interface{int}
+	T2 interface{~int}
+	T3 interface{T1 | bool | string}
+	T4 interface{T2 | ~bool | ~string}
+)
+
+type (
+	// overlap errors for non-interface terms
+	// (like the interface terms, but explicitly inlined)
+	_ interface{int | int /* ERROR overlapping terms int and int */ }
+	_ interface{int | ~ /* ERROR overlapping terms ~int and int */ int}
+	_ interface{~int | int /* ERROR overlapping terms int and ~int */ }
+	_ interface{~int | ~ /* ERROR overlapping terms ~int and ~int */ int}
+
+	_ interface{T1 | bool | string | T1 | bool /* ERROR overlapping terms bool and bool */ | string /* ERROR overlapping terms string and string */ }
+	_ interface{T1 | bool | string | T2 | ~ /* ERROR overlapping terms ~bool and bool */ bool | ~ /* ERROR overlapping terms ~string and string */ string}
+
+	// no errors for interface terms
+	_ interface{T1 | T1}
+	_ interface{T1 | T2}
+	_ interface{T2 | T1}
+	_ interface{T2 | T2}
+
+	_ interface{T3 | T3 | int}
+	_ interface{T3 | T4 | bool }
+	_ interface{T4 | T3 | string }
+	_ interface{T4 | T4 | float64 }
+)
+
+func _[_ T1 | bool | string | T1 | bool /* ERROR overlapping terms */ ]() {}
+func _[_ T1 | bool | string | T2 | ~ /* ERROR overlapping terms */ bool ]() {}
+func _[_ T2 | ~bool | ~string | T1 | bool /* ERROR overlapping terms */ ]() {}
+func _[_ T2 | ~bool | ~string | T2 | ~ /* ERROR overlapping terms */ bool ]() {}
+
+func _[_ T3 | T3 | int]() {}
+func _[_ T3 | T4 | bool]() {}
+func _[_ T4 | T3 | string]() {}
+func _[_ T4 | T4 | float64]() {}
+
+// test cases from issue
+
+type _ interface {
+	interface {bool | int} | interface {bool | string}
+}
+
+type _ interface {
+	interface {bool | int} ; interface {bool | string}
+}
+
+type _ interface {
+	interface {bool; int} ; interface {bool; string}
+}
+
+type _ interface {
+	interface {bool; int} | interface {bool; string}
+}
\ No newline at end of file
diff --git a/src/cmd/compile/internal/types2/union.go b/src/cmd/compile/internal/types2/union.go
index e317b9cced..4a146f87a2 100644
--- a/src/cmd/compile/internal/types2/union.go
+++ b/src/cmd/compile/internal/types2/union.go
@@ -113,14 +113,12 @@ func parseUnion(check *Checker, uexpr syntax.Expr) Type {
 				switch {
 				case tset.NumMethods() != 0:
 					check.errorf(tlist[i], "cannot use %s in union (%s contains methods)", t, t)
-					continue
 				case t.typ == universeComparable.Type():
 					check.error(tlist[i], "cannot use comparable in union")
-					continue
 				case tset.comparable:
 					check.errorf(tlist[i], "cannot use %s in union (%s embeds comparable)", t, t)
-					continue
 				}
+				continue // terms with interface types are not subject to the no-overlap rule
 			}
 
 			// Report overlapping (non-disjoint) terms such as
@@ -160,10 +158,16 @@ func parseTilde(check *Checker, tx syntax.Expr) *Term {
 
 // overlappingTerm reports the index of the term x in terms which is
 // overlapping (not disjoint) from y. The result is < 0 if there is no
-// such term.
+// such term. The type of term y must not be an interface, and terms
+// with an interface type are ignored in the terms list.
 func overlappingTerm(terms []*Term, y *Term) int {
+	assert(!IsInterface(y.typ))
 	for i, x := range terms {
-		// disjoint requires non-nil, non-top arguments
+		if IsInterface(x.typ) {
+			continue
+		}
+		// disjoint requires non-nil, non-top arguments,
+		// and non-interface types as term types.
 		if debug {
 			if x == nil || x.typ == nil || y == nil || y.typ == nil {
 				panic("empty or top union term")
diff --git a/src/go/types/testdata/examples/constraints.go2 b/src/go/types/testdata/examples/constraints.go2
index 4d7f70313a..0d3e282529 100644
--- a/src/go/types/testdata/examples/constraints.go2
+++ b/src/go/types/testdata/examples/constraints.go2
@@ -24,7 +24,8 @@ type (
 	_ interface{int|any}
 	_ interface{int|~string|union}
 	_ interface{int|~string|interface{int}}
-	_ interface{union|union /* ERROR overlapping terms p.union and p.union */ }
+	_ interface{union|int}   // interfaces (here: union) are ignored when checking for overlap
+	_ interface{union|union} // ditto
 
 	// For now we do not permit interfaces with methods in unions.
 	_ interface{~ /* ERROR invalid use of ~ */ any}
diff --git a/src/go/types/union.go b/src/go/types/union.go
index 8397d65af0..f30e9ec8a8 100644
--- a/src/go/types/union.go
+++ b/src/go/types/union.go
@@ -116,14 +116,12 @@ func parseUnion(check *Checker, uexpr ast.Expr) Type {
 				switch {
 				case tset.NumMethods() != 0:
 					check.errorf(tlist[i], _InvalidUnion, "cannot use %s in union (%s contains methods)", t, t)
-					continue
 				case t.typ == universeComparable.Type():
 					check.error(tlist[i], _InvalidUnion, "cannot use comparable in union")
-					continue
 				case tset.comparable:
 					check.errorf(tlist[i], _InvalidUnion, "cannot use %s in union (%s embeds comparable)", t, t)
-					continue
 				}
+				continue // terms with interface types are not subject to the no-overlap rule
 			}
 
 			// Report overlapping (non-disjoint) terms such as
@@ -163,10 +161,16 @@ func parseTilde(check *Checker, tx ast.Expr) *Term {
 
 // overlappingTerm reports the index of the term x in terms which is
 // overlapping (not disjoint) from y. The result is < 0 if there is no
-// such term.
+// such term. The type of term y must not be an interface, and terms
+// with an interface type are ignored in the terms list.
 func overlappingTerm(terms []*Term, y *Term) int {
+	assert(!IsInterface(y.typ))
 	for i, x := range terms {
-		// disjoint requires non-nil, non-top arguments
+		if IsInterface(x.typ) {
+			continue
+		}
+		// disjoint requires non-nil, non-top arguments,
+		// and non-interface types as term types.
 		if debug {
 			if x == nil || x.typ == nil || y == nil || y.typ == nil {
 				panic("empty or top union term")