diff options
Diffstat (limited to 'test/typeparam/typelist.go')
-rw-r--r-- | test/typeparam/typelist.go | 138 |
1 files changed, 138 insertions, 0 deletions
diff --git a/test/typeparam/typelist.go b/test/typeparam/typelist.go new file mode 100644 index 0000000..7c71321 --- /dev/null +++ b/test/typeparam/typelist.go @@ -0,0 +1,138 @@ +// compile + +// 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. + +// This file tests type lists & constraints with core types. + +// Note: This test has been adjusted to use the new +// type set notation rather than type lists. + +package p + +// Assignability of an unnamed pointer type to a type parameter that +// has a matching underlying type. +func _[T interface{}, PT interface{ ~*T }](x T) PT { + return &x +} + +// Indexing of generic types containing type parameters in their type list: +func at[T interface{ ~[]E }, E any](x T, i int) E { + return x[i] +} + +// A generic type inside a function acts like a named type. Its underlying +// type is itself, its "operational type" is defined by the type list in +// the tybe bound, if any. +func _[T interface{ ~int }](x T) { + var _ int = int(x) + var _ T = 42 + var _ T = T(myint(42)) +} + +// TODO: put this type declaration back inside the above function when issue 47631 is fixed. +type myint int + +// Indexing a generic type which has a an array as core type. +func _[T interface{ ~[10]int }](x T) { + _ = x[9] // ok +} + +// Dereference of a generic type which has a pointer as core type. +func _[T interface{ ~*int }](p T) int { + return *p +} + +// Channel send and receive on a generic type which has a channel as core type. +func _[T interface{ ~chan int }](ch T) int { + // This would deadlock if executed (but ok for a compile test) + ch <- 0 + return <-ch +} + +// Calling of a generic type which has a function as core type. +func _[T interface{ ~func() }](f T) { + f() + go f() +} + +// Same, but function has a parameter and return value. +func _[T interface{ ~func(string) int }](f T) int { + return f("hello") +} + +// Map access of a generic type which has a map as core type. +func _[V any, T interface{ ~map[string]V }](p T) V { + return p["test"] +} + +// 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 f0x() { + f := f0[string] + f("a", "b", "c", "d") + f0("a", "b", "c", "d") +} + +func f1[A any, B interface{type A}](A, B) +func f1x() { + f := f1[int] + f(int(0), int(0)) + f1(int(0), int(0)) + f(0, 0) + f1(0, 0) +} +*/ + +func f2[A any, B interface{ []A }](_ A, _ B) {} +func f2x() { + f := f2[byte] + f(byte(0), []byte{}) + f2(byte(0), []byte{}) + f(0, []byte{}) + // 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 f3x() { + 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 C) {} +func f4x() { + f := f4[int] + var x int + f(x, []*int{}, &x) + f4(x, []*int{}, &x) +} + +func f5[A interface { + struct { + b B + c C + } +}, B any, C interface{ *B }](x B) A { + panic(0) +} +func f5x() { + x := f5(1.2) + var _ float64 = x.b + var _ float64 = *x.c +} + +func f6[A any, B interface{ ~struct{ f []A } }](B) A { panic(0) } +func f6x() { + x := f6(struct{ f []string }{}) + var _ string = x +} |