[dev.go2go] go/types: interfaces with type lists are only allowed as constraints

Check that such constraint interfaces don't appear in:
- composite types
- type and function instantiations
- assertions
- type switches

Streamlined respective error messages. Added lots of tests.

Fixes #41124.

Change-Id: Ie04a95ab056b40561484f04ed6e843ca371e1d41
Reviewed-on: https://go-review.googlesource.com/c/go/+/251718
Run-TryBot: Robert Griesemer <[email protected]>
TryBot-Result: Gobot Gobot <[email protected]>
Reviewed-by: Robert Griesemer <[email protected]>

Author: griesemer

src/go/types/builtins.go

@@ -506,7 +506,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	case _New:
 		// new(T)
 		// (no argument evaluated yet)
-		T := check.typ(call.Args[0])
+		T := check.varType(call.Args[0])
 		if T == Typ[Invalid] {
 			return
 		}

src/go/types/call.go

@@ -143,6 +143,14 @@ func (check *Checker) call(x *operand, call *ast.CallExpr) exprKind {
 			assert(n == len(sig.tparams))
 
 			// instantiate function signature
+			for i, typ := range targs {
+				// some positions may be missing if types are inferred
+				var pos token.Pos
+				if i < len(poslist) {
+					pos = poslist[i]
+				}
+				check.ordinaryType(pos, typ)
+			}
 			res := check.instantiate(x.pos(), sig, targs, poslist).(*Signature)
 			assert(res.tparams == nil) // signature is not generic anymore
 			x.typ = res

src/go/types/examples/types.go2

@@ -251,16 +251,16 @@ type I interface {
 }
 
 var (
-	_ interface /* ERROR cannot contain type constraints */ {type int}
-	_ I /* ERROR cannot contain type constraints */
+	_ interface /* ERROR contains type constraints */ {type int}
+	_ I /* ERROR contains type constraints */
 )
 
-func _(I /* ERROR cannot contain type constraints */ )
-func _(x, y, z I /* ERROR cannot contain type constraints */ )
-func _() I /* ERROR cannot contain type constraints */
+func _(I /* ERROR contains type constraints */ )
+func _(x, y, z I /* ERROR contains type constraints */ )
+func _() I /* ERROR contains type constraints */
 
 func _() {
-	var _ I /* ERROR cannot contain type constraints */
+	var _ I /* ERROR contains type constraints */
 }
 
 type C interface {

src/go/types/expr.go

@@ -1123,7 +1123,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 					// We have an "open" [...]T array type.
 					// Create a new ArrayType with unknown length (-1)
 					// and finish setting it up after analyzing the literal.
-					typ = &Array{len: -1, elem: check.typ(atyp.Elt)}
+					typ = &Array{len: -1, elem: check.varType(atyp.Elt)}
 					base = typ
 					break
 				}
@@ -1335,7 +1335,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 				if isGeneric(x.typ) {
 					// type instantiation
 					x.mode = invalid
-					x.typ = check.typ(e)
+					x.typ = check.varType(e)
 					if x.typ != Typ[Invalid] {
 						x.mode = typexpr
 					}
@@ -1590,7 +1590,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			check.invalidAST(e.Pos(), "use of .(type) outside type switch")
 			goto Error
 		}
-		T := check.typ(e.Type)
+		T := check.varType(e.Type)
 		if T == Typ[Invalid] {
 			goto Error
 		}

src/go/types/fixedbugs/issue39634.go2

@@ -36,8 +36,8 @@ func bar8[A foo8[A]](a A) {}
 func main8() {}
 
 // crash 9
-type foo9[A any] interface { type foo9[A] }
-func _() { var _ = new(foo9[int]) }
+type foo9[A any] interface { type foo9 /* ERROR interface contains type constraints */ [A] }
+func _() { var _ = new(foo9 /* ERROR interface contains type constraints */ [int]) }
 
 // crash 12
 var u /* ERROR cycle */ , i [func /* ERROR used as value */ /* ERROR used as value */ (u, c /* ERROR undeclared */ /* ERROR undeclared */ ) {}(0, len)]c /* ERROR undeclared */ /* ERROR undeclared */

src/go/types/fixedbugs/issue41124.go2

@@ -0,0 +1,91 @@
+// Copyright 2020 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
+
+// Test case from issue.
+
+type Nat interface {
+	type Zero, Succ
+}
+
+type Zero struct{}
+type Succ struct{
+	Nat // ERROR interface contains type constraints
+}
+
+// Struct tests.
+
+type I1 interface {
+	comparable
+}
+
+type I2 interface {
+	type int
+}
+
+type I3 interface {
+	I1
+	I2
+}
+
+type _ struct {
+	f I1 // ERROR interface is .* comparable
+}
+
+type _ struct {
+	comparable // ERROR interface is .* comparable
+}
+
+type _ struct{
+	I1 // ERROR interface is .* comparable
+}
+
+type _ struct{
+	I2 // ERROR interface contains type constraints
+}
+
+type _ struct{
+	I3 // ERROR interface contains type constraints
+}
+
+// General composite types.
+
+type (
+	_ [10]I1 // ERROR interface is .* comparable
+	_ [10]I2 // ERROR interface contains type constraints
+
+	_ []I1 // ERROR interface is .* comparable
+	_ []I2 // ERROR interface contains type constraints
+
+	_ *I3 // ERROR interface contains type constraints
+	_ map[I1 /* ERROR interface is .* comparable */ ]I2 // ERROR interface contains type constraints
+	_ chan I3 // ERROR interface contains type constraints
+	_ func(I1 /* ERROR interface is .* comparable */ )
+	_ func() I2 // ERROR interface contains type constraints
+)
+
+// Other cases.
+
+var _ = [...]I3 /* ERROR interface contains type constraints */ {}
+
+func _(x interface{}) {
+	_ = x.(I3 /* ERROR interface contains type constraints */ )
+}
+
+type T1[_ any] struct{}
+type T3[_, _, _ any] struct{}
+var _ T1[I2 /* ERROR interface contains type constraints */ ]
+var _ T3[int, I2 /* ERROR interface contains type constraints */ , float32]
+
+func f1[_ any]() int
+var _ = f1[I2 /* ERROR interface contains type constraints */ ]()
+func f3[_, _, _ any]() int
+var _ = f3[int, I2 /* ERROR interface contains type constraints */ , float32]()
+
+func _(x interface{}) {
+	switch x.(type) {
+	case I2 /* ERROR interface contains type constraints */ :
+	}
+}

src/go/types/stmt.go

@@ -272,6 +272,9 @@ L:
 		if T == Typ[Invalid] {
 			continue L
 		}
+		if T != nil {
+			check.ordinaryType(e.Pos(), T)
+		}
 		// look for duplicate types
 		// (quadratic algorithm, but type switches tend to be reasonably small)
 		for t, pos := range seen {

src/go/types/typexpr.go

@@ -124,26 +124,32 @@ func (check *Checker) typ(e ast.Expr) Type {
 }
 
 // varType type-checks the type expression e and returns its type, or Typ[Invalid].
-// The type must not be an (uninstantiated) generic type and it must not be an
-// interface type containing type lists.
+// The type must not be an (uninstantiated) generic type and it must be ordinary
+// (see ordinaryType).
 func (check *Checker) varType(e ast.Expr) Type {
 	typ := check.definedType(e, nil)
-	if t := typ.Interface(); t != nil {
-		// We don't want to complete interfaces while we are in the middle
-		// of type-checking parameter declarations that might belong to
-		// interface methods. Delay this check to the end of type-checking.
-		check.atEnd(func() {
-			check.completeInterface(e.Pos(), t) // TODO(gri) is this the correct position?
+	check.ordinaryType(e.Pos(), typ)
+	return typ
+}
+
+// ordinaryType reports an error if typ is an interface type containing
+// type lists or is (or embeds) the predeclared type comparable.
+func (check *Checker) ordinaryType(pos token.Pos, typ Type) {
+	// We don't want to call Under() (via Interface) or complete interfaces while we
+	// are in the middle of type-checking parameter declarations that might belong to
+	// interface methods. Delay this check to the end of type-checking.
+	check.atEnd(func() {
+		if t := typ.Interface(); t != nil {
+			check.completeInterface(pos, t) // TODO(gri) is this the correct position?
 			if t.allTypes != nil {
-				check.softErrorf(e.Pos(), "interface type for variable cannot contain type constraints (%s)", t.allTypes)
+				check.softErrorf(pos, "interface contains type constraints (%s)", t.allTypes)
 				return
 			}
 			if t.IsComparable() {
-				check.softErrorf(e.Pos(), "interface type for variable cannot be (or embed) comparable")
+				check.softErrorf(pos, "interface is (or embeds) comparable")
 			}
-		})
-	}
-	return typ
+		}
+	})
 }
 
 // anyType type-checks the type expression e and returns its type, or Typ[Invalid].
@@ -477,13 +483,13 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 			typ := new(Array)
 			def.setUnderlying(typ)
 			typ.len = check.arrayLength(e.Len)
-			typ.elem = check.typ(e.Elt)
+			typ.elem = check.varType(e.Elt)
 			return typ
 		}
 
 		typ := new(Slice)
 		def.setUnderlying(typ)
-		typ.elem = check.typ(e.Elt)
+		typ.elem = check.varType(e.Elt)
 		return typ
 
 	case *ast.StructType:
@@ -495,7 +501,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 	case *ast.StarExpr:
 		typ := new(Pointer)
 		def.setUnderlying(typ)
-		typ.base = check.typ(e.X)
+		typ.base = check.varType(e.X)
 		return typ
 
 	case *ast.FuncType:
@@ -517,8 +523,8 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		typ := new(Map)
 		def.setUnderlying(typ)
 
-		typ.key = check.typ(e.Key)
-		typ.elem = check.typ(e.Value)
+		typ.key = check.varType(e.Key)
+		typ.elem = check.varType(e.Value)
 
 		// spec: "The comparison operators == and != must be fully defined
 		// for operands of the key type; thus the key type must not be a
@@ -556,7 +562,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		}
 
 		typ.dir = dir
-		typ.elem = check.typ(e.Value)
+		typ.elem = check.varType(e.Value)
 		return typ
 
 	default:
@@ -670,7 +676,7 @@ func (check *Checker) arrayLength(e ast.Expr) int64 {
 func (check *Checker) typeList(list []ast.Expr) []Type {
 	res := make([]Type, len(list)) // res != nil even if len(list) == 0
 	for i, x := range list {
-		t := check.typ(x)
+		t := check.varType(x)
 		if t == Typ[Invalid] {
 			res = nil
 		}
@@ -1054,7 +1060,7 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 	}
 
 	for _, f := range list.List {
-		typ = check.typ(f.Type)
+		typ = check.varType(f.Type)
 		tag = check.tag(f.Tag)
 		if len(f.Names) > 0 {
 			// named fields
@@ -1134,7 +1140,7 @@ func (check *Checker) collectTypeConstraints(pos token.Pos, types []ast.Expr) []
 			check.invalidAST(pos, "missing type constraint")
 			continue
 		}
-		typ := check.typ(texpr)
+		typ := check.varType(texpr)
 		// A type constraint may be a predeclared type or a
 		// composite type composed of only predeclared types.
 		// TODO(gri) If we enable this again it also must run