For #47127.
Change-Id: Ie979ff56ae7c2dd0e5ce0ff39588f98ae68b5ee9
Reviewed-on: https://go-review.googlesource.com/c/go/+/334151
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>
type sliceOf[E any] interface{ ~[]E }
-func append[T interface{}, S sliceOf[T], T2 interface{ T }](s S, t ...T2) S
+func append[T interface{}, S sliceOf[T], T2 interface{}](s S, t ...T2) S
var f func()
var cancelSlice []context.CancelFunc
type any interface{}
-func f0[A any, B interface{~C}, C interface{~D}, D interface{~A}](A, B, C, D)
-func _() {
- f := f0[string]
- f("a", "b", "c", "d")
- f0("a", "b", "c", "d")
-}
-
-func f1[A any, B interface{~A}](A, B)
-func _() {
- f := f1[int]
- f(int(0), int(0))
- f1(int(0), int(0))
-}
+// Embedding stand-alone type parameters is not permitted for now. Disabled.
+// func f0[A any, B interface{~C}, C interface{~D}, D interface{~A}](A, B, C, D)
+// func _() {
+// f := f0[string]
+// f("a", "b", "c", "d")
+// f0("a", "b", "c", "d")
+// }
+//
+// func f1[A any, B interface{~A}](A, B)
+// func _() {
+// f := f1[int]
+// f(int(0), int(0))
+// f1(int(0), int(0))
+// }
func f2[A any, B interface{~[]A}](A, B)
func _() {
f2(byte(0), []byte{})
}
-func f3[A any, B interface{~C}, C interface{~*A}](A, B, C)
-func _() {
- f := f3[int]
- var x int
- f(x, &x, &x)
- f3(x, &x, &x)
-}
+// Embedding stand-alone type parameters is not permitted for now. Disabled.
+// func f3[A any, B interface{~C}, C interface{~*A}](A, B, C)
+// func _() {
+// f := f3[int]
+// var x int
+// f(x, &x, &x)
+// f3(x, &x, &x)
+// }
func f4[A any, B interface{~[]C}, C interface{~*A}](A, B, C)
func _() {
func main7() { var _ foo7 = x7[int]{} }
// crash 8
-type foo8[A any] interface { ~A }
-func bar8[A foo8[A]](a A) {}
-func main8() {}
+// Embedding stand-alone type parameters is not permitted for now. Disabled.
+// type foo8[A any] interface { ~A }
+// func bar8[A foo8[A]](a A) {}
+// func main8() {}
// crash 9
type foo9[A any] interface { foo9 /* ERROR illegal cycle */ [A] }
package p
+// Embedding stand-alone type parameters is not permitted for now. Disabled.
+
+/*
import "fmt"
// Minimal test case.
func f() {
Print([]string{"Hello, ", "playground\n"})
}
+*/
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// TODO(gri) Eventually, once we disallow type lists, we need to
-// adjust this code: for 1.17 we don't accept type parameters,
-// and for 1.18 this code is valid.
-// Leaving for now so we can see that existing errors
-// are being reported.
-
-package go1_17 // don't permit non-interface elements in interfaces
+package p
type T[P any] interface{
- P // ERROR P is a type parameter, not an interface
+ P // ERROR cannot embed a type parameter
}
--- /dev/null
+// Copyright 2021 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.
+
+// Embedding of stand-alone type parameters is not permitted.
+
+package p
+
+type (
+ _[P any] interface{ *P | []P | chan P | map[string]P }
+ _[P any] interface{ P /* ERROR "cannot embed a type parameter" */ }
+ _[P any] interface{ ~P /* ERROR "cannot embed a type parameter" */ }
+ _[P any] interface{ int | P /* ERROR "cannot embed a type parameter" */ }
+ _[P any] interface{ int | ~P /* ERROR "cannot embed a type parameter" */ }
+)
+
+func _[P any]() {
+ type (
+ _[P any] interface{ *P | []P | chan P | map[string]P }
+ _[P any] interface{ P /* ERROR "cannot embed a type parameter" */ }
+ _[P any] interface{ ~P /* ERROR "cannot embed a type parameter" */ }
+ _[P any] interface{ int | P /* ERROR "cannot embed a type parameter" */ }
+ _[P any] interface{ int | ~P /* ERROR "cannot embed a type parameter" */ }
+
+ _ interface{ *P | []P | chan P | map[string]P }
+ _ interface{ P /* ERROR "cannot embed a type parameter" */ }
+ _ interface{ ~P /* ERROR "cannot embed a type parameter" */ }
+ _ interface{ int | P /* ERROR "cannot embed a type parameter" */ }
+ _ interface{ int | ~P /* ERROR "cannot embed a type parameter" */ }
+ )
+}
+
+func _[P any, Q interface{ *P | []P | chan P | map[string]P }]()
+func _[P any, Q interface{ P /* ERROR "cannot embed a type parameter" */ }]()
+func _[P any, Q interface{ ~P /* ERROR "cannot embed a type parameter" */ }]()
+func _[P any, Q interface{ int | P /* ERROR "cannot embed a type parameter" */ }]()
+func _[P any, Q interface{ int | ~P /* ERROR "cannot embed a type parameter" */ }]()
// interface before go1.18.
types = typ
case *TypeParam:
- if check != nil && !check.allowVersion(check.pkg, 1, 18) {
- check.errorf(pos, "%s is a type parameter, not an interface", typ)
- continue
- }
- types = typ
+ // Embedding stand-alone type parameters is not permitted for now.
+ // This case is handled during union parsing.
+ unreachable()
default:
if typ == Typ[Invalid] {
continue
return newUnion(types, tilde)
}
-func parseTilde(check *Checker, x syntax.Expr) (Type, bool) {
- tilde := false
+func parseTilde(check *Checker, x syntax.Expr) (typ Type, tilde bool) {
if op, _ := x.(*syntax.Operation); op != nil && op.Op == syntax.Tilde {
x = op.X
tilde = true
}
- return check.anyType(x), tilde
+ typ = check.anyType(x)
+ // embedding stand-alone type parameters is not permitted (issue #47127).
+ if _, ok := under(typ).(*TypeParam); ok {
+ check.error(x, "cannot embed a type parameter")
+ typ = Typ[Invalid]
+ }
+ return
}
// intersect computes the intersection of the types x and y,
// Testing partial and full type inference, including the case where the types can
// be inferred without needing the types of the function arguments.
+// Cannot embed stand-alone type parameters. Disabled for now.
+/*
func f0[A any, B interface{type C}, C interface{type D}, D interface{type A}](A, B, C, D)
func _() {
f := f0[string]
f(0, 0)
f1(0, 0)
}
+*/
func f2[A any, B interface{type []A}](_ A, _ B)
func _() {
// f2(0, []byte{}) - this one doesn't work
}
+// Cannot embed stand-alone type parameters. Disabled for now.
+/*
func f3[A any, B interface{type C}, C interface{type *A}](a A, _ B, c C)
func _() {
f := f3[int]
f(x, &x, &x)
f3(x, &x, &x)
}
+*/
func f4[A any, B interface{type []C}, C interface{type *A}](_ A, _ B, c C)
func _() {