[dev.typeparams] cmd/compile/internal/types2: introduce type set abstraction for interfaces

With this change, interfaces are "completed" on-demand, when needed,
and the respective information (set of all methods, type constraints)
is recorded in a new typeSet data structure.

As a consequence, interfaces don't need to be explicitly completed
anymore and (internal) uses of interfaces have become much simpler.

This change also introduces a new field Interface.complete to indicate
that all methods and embedded elements have been set up. This prevent
the computation and recording (!) of a partial type set for erroneous
programs (if we compute the partial type set and store it, subsequent
type set accesses use the wrong type set which may lead to follow-on
errors).

Change-Id: I1ffc907f7d0fb93b3e987fe5ff9c6fa5cae00d7f
Reviewed-on: https://go-review.googlesource.com/c/go/+/329309
Trust: Robert Griesemer <gri@golang.org>
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>

1 files changed, 13 insertions, 2 deletions

diff --git a/src/cmd/compile/internal/types2/testdata/check/cycles4.src b/src/cmd/compile/internal/types2/testdata/check/cycles4.src
index 445babca68..924aabf475 100644
--- a/src/cmd/compile/internal/types2/testdata/check/cycles4.src
+++ b/src/cmd/compile/internal/types2/testdata/check/cycles4.src
@@ -4,6 +4,8 @@
 
 package p
 
+import "unsafe"
+
 // Check that all methods of T are collected before
 // determining the result type of m (which embeds
 // all methods of T).
@@ -13,7 +15,7 @@ type T interface {
 	E
 }
 
-var _ = T.m(nil).m().e()
+var _ int = T.m(nil).m().e()
 
 type E interface {
 	e() int
@@ -22,7 +24,7 @@ type E interface {
 // Check that unresolved forward chains are followed
 // (see also comment in resolver.go, checker.typeDecl).
 
-var _ = C.m(nil).m().e()
+var _ int = C.m(nil).m().e()
 
 type A B
 
@@ -108,3 +110,12 @@ type Element interface {
 type Event interface {
 	Target() Element
 }
+
+// Check that accessing an interface method too early doesn't lead
+// to follow-on errors due to an incorrectly computed type set.
+
+type T8 interface {
+	m() [unsafe.Sizeof(T8.m /* ERROR undefined */ )]int
+}
+
+var _ = T8.m // no error expected here