[dev.typeparams] cmd/compile/internal/types2: remove TestIncompleteInterfaces (cleanup)

TestIncompleteInterfaces is not useful anymore because interface
printing always shows the syntactic type structure of an interface.

Also remove the respective support code in interface printing and
simplify that code.

Move the newDefined and nopos support declarations unchanged into
api_test.go where they are used.

Updates #46167.

Change-Id: I23e303bc4ae4271912ba75f201bd2b7cd4a17b3e
Reviewed-on: https://go-review.googlesource.com/c/go/+/339832
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 1d3347a6deacc6a5bb76527e1914ec82c10c5b7a..c625bd49594a7cebdc79c64fed57b4c2be5791b2 100644 (file)
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -1567,6 +1567,14 @@ func F(){
        }
 }
 
+var nopos syntax.Pos
+
+// newDefined creates a new defined type named T with the given underlying type.
+func newDefined(underlying Type) *Named {
+       tname := NewTypeName(nopos, nil, "T", nil)
+       return NewNamed(tname, underlying, nil)
+}
+
 func TestConvertibleTo(t *testing.T) {
        for _, test := range []struct {
                v, t Type

diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 1416008b163854ea23154732658ee0fdd52f1b9f..628eeaf3ddab2c01cd8bcbef80773c45584d62f6 100644 (file)
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -144,32 +144,21 @@ func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
 
        case *Interface:
                buf.WriteString("interface{")
-               empty := true
-               for i, m := range t.methods {
-                       if i > 0 {
+               first := true
+               for _, m := range t.methods {
+                       if !first {
                                buf.WriteString("; ")
                        }
+                       first = false
                        buf.WriteString(m.name)
                        writeSignature(buf, m.typ.(*Signature), qf, visited)
-                       empty = false
-               }
-               if !empty && len(t.embeddeds) > 0 {
-                       buf.WriteString("; ")
                }
-               for i, typ := range t.embeddeds {
-                       if i > 0 {
+               for _, typ := range t.embeddeds {
+                       if !first {
                                buf.WriteString("; ")
                        }
+                       first = false
                        writeType(buf, typ, qf, visited)
-                       empty = false
-               }
-               // print /* incomplete */ if needed to satisfy existing tests
-               // TODO(gri) get rid of this eventually
-               if debug && t.tset == nil {
-                       if !empty {
-                               buf.WriteByte(' ')
-                       }
-                       buf.WriteString("/* incomplete */")
                }
                buf.WriteByte('}')
 

diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go
index 88103b81b12a086f6260dcd2f18351efec8261db..0ed29349610912978106e64705ff8207182a6823 100644 (file)
--- a/src/cmd/compile/internal/types2/typestring_test.go
+++ b/src/cmd/compile/internal/types2/typestring_test.go
@@ -136,64 +136,6 @@ func TestTypeString(t *testing.T) {
        }
 }
 
-var nopos syntax.Pos
-
-func TestIncompleteInterfaces(t *testing.T) {
-       if !Debug {
-               t.Skip("requires type checker to be compiled with debug = true")
-       }
-
-       sig := NewSignature(nil, nil, nil, false)
-       m := NewFunc(nopos, nil, "m", sig)
-       for _, test := range []struct {
-               typ  *Interface
-               want string
-       }{
-               {new(Interface), "interface{/* incomplete */}"},
-               {new(Interface).Complete(), "interface{}"},
-
-               {NewInterface(nil, nil), "interface{}"},
-               {NewInterface(nil, nil).Complete(), "interface{}"},
-               {NewInterface([]*Func{}, nil), "interface{}"},
-               {NewInterface([]*Func{}, nil).Complete(), "interface{}"},
-               {NewInterface(nil, []*Named{}), "interface{}"},
-               {NewInterface(nil, []*Named{}).Complete(), "interface{}"},
-               {NewInterface([]*Func{m}, nil), "interface{m() /* incomplete */}"},
-               {NewInterface([]*Func{m}, nil).Complete(), "interface{m()}"},
-               {NewInterface(nil, []*Named{newDefined(new(Interface).Complete())}), "interface{T /* incomplete */}"},
-               {NewInterface(nil, []*Named{newDefined(new(Interface).Complete())}).Complete(), "interface{T}"},
-               {NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil))}), "interface{T /* incomplete */}"},
-               {NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil).Complete())}), "interface{T /* incomplete */}"},
-               {NewInterface(nil, []*Named{newDefined(NewInterface([]*Func{m}, nil).Complete())}).Complete(), "interface{T}"},
-
-               {NewInterfaceType(nil, nil), "interface{}"},
-               {NewInterfaceType(nil, nil).Complete(), "interface{}"},
-               {NewInterfaceType([]*Func{}, nil), "interface{}"},
-               {NewInterfaceType([]*Func{}, nil).Complete(), "interface{}"},
-               {NewInterfaceType(nil, []Type{}), "interface{}"},
-               {NewInterfaceType(nil, []Type{}).Complete(), "interface{}"},
-               {NewInterfaceType([]*Func{m}, nil), "interface{m() /* incomplete */}"},
-               {NewInterfaceType([]*Func{m}, nil).Complete(), "interface{m()}"},
-               {NewInterfaceType(nil, []Type{new(Interface).Complete()}), "interface{interface{} /* incomplete */}"},
-               {NewInterfaceType(nil, []Type{new(Interface).Complete()}).Complete(), "interface{interface{}}"},
-               {NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil)}), "interface{interface{m() /* incomplete */} /* incomplete */}"},
-               {NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil).Complete()}), "interface{interface{m()} /* incomplete */}"},
-               {NewInterfaceType(nil, []Type{NewInterfaceType([]*Func{m}, nil).Complete()}).Complete(), "interface{interface{m()}}"},
-       } {
-               got := test.typ.String()
-               if got != test.want {
-                       t.Errorf("got: %s, want: %s", got, test.want)
-               }
-       }
-}
-
-// newDefined creates a new defined type named T with the given underlying type.
-// Helper function for use with TestIncompleteInterfaces only.
-func newDefined(underlying Type) *Named {
-       tname := NewTypeName(nopos, nil, "T", nil)
-       return NewNamed(tname, underlying, nil)
-}
-
 func TestQualifiedTypeString(t *testing.T) {
        p, _ := pkgFor("p.go", "package p; type T int", nil)
        q, _ := pkgFor("q.go", "package q", nil)