Text file src/go/types/testdata/check/typeparams.go2

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package p
     6  
     7  // import "io" // for type assertion tests
     8  
     9  var _ any // ok to use any anywhere
    10  func _[_ any, _ interface{any}](any) {
    11          var _ any
    12  }
    13  
    14  func identity[T any](x T) T { return x }
    15  
    16  func _[_ any](x int) int { panic(0) }
    17  func _[T any](T /* ERROR redeclared */ T)() {}
    18  func _[T, T /* ERROR redeclared */ any]() {}
    19  
    20  // Constraints (incl. any) may be parenthesized.
    21  func _[_ (any)]() {}
    22  func _[_ (interface{})]() {}
    23  
    24  func reverse[T any](list []T) []T {
    25          rlist := make([]T, len(list))
    26          i := len(list)
    27          for _, x := range list {
    28                  i--
    29                  rlist[i] = x
    30          }
    31          return rlist
    32  }
    33  
    34  var _ = reverse /* ERROR cannot use generic function reverse */
    35  var _ = reverse[int, float32 /* ERROR got 2 type arguments */ ] ([]int{1, 2, 3})
    36  var _ = reverse[int]([ /* ERROR cannot use */ ]float32{1, 2, 3})
    37  var f = reverse[chan int]
    38  var _ = f(0 /* ERROR cannot use 0 .* as \[\]chan int */ )
    39  
    40  func swap[A, B any](a A, b B) (B, A) { return b, a }
    41  
    42  var _ = swap /* ERROR single value is expected */ [int, float32](1, 2)
    43  var f32, i = swap[int, float32](swap[float32, int](1, 2))
    44  var _ float32 = f32
    45  var _ int = i
    46  
    47  func swapswap[A, B any](a A, b B) (A, B) {
    48          return swap[B, A](b, a)
    49  }
    50  
    51  type F[A, B any] func(A, B) (B, A)
    52  
    53  func min[T interface{ ~int }](x, y T) T {
    54          if x < y {
    55                  return x
    56          }
    57          return y
    58  }
    59  
    60  func _[T interface{~int | ~float32}](x, y T) bool { return x < y }
    61  func _[T any](x, y T) bool { return x /* ERROR cannot compare */ < y }
    62  func _[T interface{~int | ~float32 | ~bool}](x, y T) bool { return x /* ERROR cannot compare */ < y }
    63  
    64  func _[T C1[T]](x, y T) bool { return x /* ERROR cannot compare */ < y }
    65  func _[T C2[T]](x, y T) bool { return x < y }
    66  
    67  type C1[T any] interface{}
    68  type C2[T any] interface{ ~int | ~float32 }
    69  
    70  func new[T any]() *T {
    71          var x T
    72          return &x
    73  }
    74  
    75  var _ = new /* ERROR cannot use generic function new */
    76  var _ *int = new[int]()
    77  
    78  func _[T any](map[T /* ERROR incomparable map key type T \(missing comparable constraint\) */]int) {} // w/o constraint we don't know if T is comparable
    79  
    80  func f1[T1 any](struct{T1 /* ERROR cannot be a .* type parameter */ }) int { panic(0) }
    81  var _ = f1[int](struct{T1}{})
    82  type T1 = int
    83  
    84  func f2[t1 any](struct{t1 /* ERROR cannot be a .* type parameter */ ; x float32}) int { panic(0) }
    85  var _ = f2[t1](struct{t1; x float32}{})
    86  type t1 = int
    87  
    88  
    89  func f3[A, B, C any](A, struct{x B}, func(A, struct{x B}, *C)) int { panic(0) }
    90  
    91  var _ = f3[int, rune, bool](1, struct{x rune}{}, nil)
    92  
    93  // indexing
    94  
    95  func _[T any] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
    96  func _[T interface{ ~int }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
    97  func _[T interface{ ~string }] (x T, i int) { _ = x[i] }
    98  func _[T interface{ ~[]int }] (x T, i int) { _ = x[i] }
    99  func _[T interface{ ~[10]int | ~*[20]int | ~map[int]int }] (x T, i int) { _ = x /* ERROR cannot index */ [i] } // map and non-map types
   100  func _[T interface{ ~string | ~[]byte }] (x T, i int) { _ = x[i] }
   101  func _[T interface{ ~[]int | ~[1]rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
   102  func _[T interface{ ~string | ~[]rune }] (x T, i int) { _ = x /* ERROR "cannot index" */ [i] }
   103  
   104  // indexing with various combinations of map types in type sets (see issue #42616)
   105  func _[T interface{ ~[]E | ~map[int]E }, E any](x T, i int) { _ = x /* ERROR cannot index */ [i] } // map and non-map types
   106  func _[T interface{ ~[]E }, E any](x T, i int) { _ = &x[i] }
   107  func _[T interface{ ~map[int]E }, E any](x T, i int) { _, _ = x[i] } // comma-ok permitted
   108  func _[T interface{ ~map[int]E }, E any](x T, i int) { _ = &x /* ERROR cannot take address */ [i] }
   109  func _[T interface{ ~map[int]E | ~map[uint]E }, E any](x T, i int) { _ = x /* ERROR cannot index */ [i] } // different map element types
   110  func _[T interface{ ~[]E | ~map[string]E }, E any](x T, i int) { _ = x /* ERROR cannot index */ [i] } // map and non-map types
   111  
   112  // indexing with various combinations of array and other types in type sets
   113  func _[T interface{ [10]int }](x T, i int) { _ = x[i]; _ = x[9]; _ = x[10 /* ERROR out of bounds */ ] }
   114  func _[T interface{ [10]byte | string }](x T, i int) { _ = x[i]; _ = x[9]; _ = x[10 /* ERROR out of bounds */ ] }
   115  func _[T interface{ [10]int | *[20]int | []int }](x T, i int) { _ = x[i]; _ = x[9]; _ = x[10 /* ERROR out of bounds */ ] }
   116  
   117  // indexing with strings and non-variable arrays (assignment not permitted)
   118  func _[T string](x T) { _ = x[0]; x /* ERROR cannot assign */ [0] = 0 }
   119  func _[T []byte | string](x T) { x /* ERROR cannot assign */ [0] = 0 }
   120  func _[T [10]byte]() { f := func() (x T) { return }; f /* ERROR cannot assign */ ()[0] = 0 }
   121  func _[T [10]byte]() { f := func() (x *T) { return }; f /* ERROR cannot index */ ()[0] = 0 }
   122  func _[T [10]byte]() { f := func() (x *T) { return }; (*f())[0] = 0 }
   123  func _[T *[10]byte]() { f := func() (x T) { return }; f()[0] = 0 }
   124  
   125  // slicing
   126  
   127  func _[T interface{ ~[10]E }, E any] (x T, i, j, k int) { var _ []E = x[i:j] }
   128  func _[T interface{ ~[10]E }, E any] (x T, i, j, k int) { var _ []E = x[i:j:k] }
   129  func _[T interface{ ~[]byte }] (x T, i, j, k int) { var _ T = x[i:j] }
   130  func _[T interface{ ~[]byte }] (x T, i, j, k int) { var _ T = x[i:j:k] }
   131  func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x[i:j] }
   132  func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x[i:j:k /* ERROR 3-index slice of string */ ] }
   133  
   134  type myByte1 []byte
   135  type myByte2 []byte
   136  func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T = x[i:j:k] }
   137  func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x /* ERROR no core type */ [i:j:k] }
   138  
   139  func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j] }
   140  func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j:k /* ERROR 3-index slice of string */ ] }
   141  func _[T interface{ []byte | myByte1 | []int | string }] (x T, i, j, k int) { var _ T = x /* ERROR no core type */ [i:j] }
   142  
   143  // len/cap built-ins
   144  
   145  func _[T any](x T) { _ = len(x /* ERROR invalid argument */ ) }
   146  func _[T interface{ ~int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
   147  func _[T interface{ ~string | ~[]byte | ~int }](x T) { _ = len(x /* ERROR invalid argument */ ) }
   148  func _[T interface{ ~string }](x T) { _ = len(x) }
   149  func _[T interface{ ~[10]int }](x T) { _ = len(x) }
   150  func _[T interface{ ~[]byte }](x T) { _ = len(x) }
   151  func _[T interface{ ~map[int]int }](x T) { _ = len(x) }
   152  func _[T interface{ ~chan int }](x T) { _ = len(x) }
   153  func _[T interface{ ~string | ~[]byte | ~chan int }](x T) { _ = len(x) }
   154  
   155  func _[T any](x T) { _ = cap(x /* ERROR invalid argument */ ) }
   156  func _[T interface{ ~int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
   157  func _[T interface{ ~string | ~[]byte | ~int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
   158  func _[T interface{ ~string }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
   159  func _[T interface{ ~[10]int }](x T) { _ = cap(x) }
   160  func _[T interface{ ~[]byte }](x T) { _ = cap(x) }
   161  func _[T interface{ ~map[int]int }](x T) { _ = cap(x /* ERROR invalid argument */ ) }
   162  func _[T interface{ ~chan int }](x T) { _ = cap(x) }
   163  func _[T interface{ ~[]byte | ~chan int }](x T) { _ = cap(x) }
   164  
   165  // range iteration
   166  
   167  func _[T interface{}](x T) {
   168          for range x /* ERROR cannot range */ {}
   169  }
   170  
   171  type myString string
   172  
   173  func _[
   174          B1 interface{ string },
   175          B2 interface{ string | myString },
   176  
   177          C1 interface{ chan int },
   178          C2 interface{ chan int | <-chan int },
   179          C3 interface{ chan<- int },
   180  
   181          S1 interface{ []int },
   182          S2 interface{ []int | [10]int },
   183  
   184          A1 interface{ [10]int },
   185          A2 interface{ [10]int | []int },
   186  
   187          P1 interface{ *[10]int },
   188          P2 interface{ *[10]int | *[]int },
   189  
   190          M1 interface{ map[string]int },
   191          M2 interface{ map[string]int | map[string]string },
   192  ]() {
   193          var b0 string
   194          for range b0 {}
   195          for _ = range b0 {}
   196          for _, _ = range b0 {}
   197  
   198          var b1 B1
   199          for range b1 {}
   200          for _ = range b1 {}
   201          for _, _ = range b1 {}
   202  
   203          var b2 B2
   204          for range b2 {}
   205  
   206          var c0 chan int
   207          for range c0 {}
   208          for _ = range c0 {}
   209          for _, _ /* ERROR permits only one iteration variable */ = range c0 {}
   210  
   211          var c1 C1
   212          for range c1 {}
   213          for _ = range c1 {}
   214          for _, _ /* ERROR permits only one iteration variable */ = range c1 {}
   215  
   216          var c2 C2
   217          for range c2 {}
   218  
   219          var c3 C3
   220          for range c3 /* ERROR receive from send-only channel */ {}
   221  
   222          var s0 []int
   223          for range s0 {}
   224          for _ = range s0 {}
   225          for _, _ = range s0 {}
   226  
   227          var s1 S1
   228          for range s1 {}
   229          for _ = range s1 {}
   230          for _, _ = range s1 {}
   231  
   232          var s2 S2
   233          for range s2 /* ERROR cannot range over s2.*no core type */ {}
   234  
   235          var a0 []int
   236          for range a0 {}
   237          for _ = range a0 {}
   238          for _, _ = range a0 {}
   239  
   240          var a1 A1
   241          for range a1 {}
   242          for _ = range a1 {}
   243          for _, _ = range a1 {}
   244  
   245          var a2 A2
   246          for range a2 /* ERROR cannot range over a2.*no core type */ {}
   247  
   248          var p0 *[10]int
   249          for range p0 {}
   250          for _ = range p0 {}
   251          for _, _ = range p0 {}
   252  
   253          var p1 P1
   254          for range p1 {}
   255          for _ = range p1 {}
   256          for _, _ = range p1 {}
   257  
   258          var p2 P2
   259          for range p2 /* ERROR cannot range over p2.*no core type */ {}
   260  
   261          var m0 map[string]int
   262          for range m0 {}
   263          for _ = range m0 {}
   264          for _, _ = range m0 {}
   265  
   266          var m1 M1
   267          for range m1 {}
   268          for _ = range m1 {}
   269          for _, _ = range m1 {}
   270  
   271          var m2 M2
   272          for range m2 /* ERROR cannot range over m2.*no core type */ {}
   273  }
   274  
   275  // type inference checks
   276  
   277  var _ = new /* ERROR cannot infer T */ ()
   278  
   279  func f4[A, B, C any](A, B) C { panic(0) }
   280  
   281  var _ = f4 /* ERROR cannot infer C */ (1, 2)
   282  var _ = f4[int, float32, complex128](1, 2)
   283  
   284  func f5[A, B, C any](A, []*B, struct{f []C}) int { panic(0) }
   285  
   286  var _ = f5[int, float32, complex128](0, nil, struct{f []complex128}{})
   287  var _ = f5 /* ERROR cannot infer */ (0, nil, struct{f []complex128}{})
   288  var _ = f5(0, []*float32{new[float32]()}, struct{f []complex128}{})
   289  
   290  func f6[A any](A, []A) int { panic(0) }
   291  
   292  var _ = f6(0, nil)
   293  
   294  func f6nil[A any](A) int { panic(0) }
   295  
   296  var _ = f6nil /* ERROR cannot infer */ (nil)
   297  
   298  // type inference with variadic functions
   299  
   300  func f7[T any](...T) T { panic(0) }
   301  
   302  var _ int = f7 /* ERROR cannot infer T */ ()
   303  var _ int = f7(1)
   304  var _ int = f7(1, 2)
   305  var _ int = f7([]int{}...)
   306  var _ int = f7 /* ERROR cannot use */ ([]float64{}...)
   307  var _ float64 = f7([]float64{}...)
   308  var _ = f7[float64](1, 2.3)
   309  var _ = f7(float64(1), 2.3)
   310  var _ = f7(1, 2.3 /* ERROR does not match */ )
   311  var _ = f7(1.2, 3 /* ERROR does not match */ )
   312  
   313  func f8[A, B any](A, B, ...B) int { panic(0) }
   314  
   315  var _ = f8(1) /* ERROR not enough arguments */
   316  var _ = f8(1, 2.3)
   317  var _ = f8(1, 2.3, 3.4, 4.5)
   318  var _ = f8(1, 2.3, 3.4, 4 /* ERROR does not match */ )
   319  var _ = f8[int, float64](1, 2.3, 3.4, 4)
   320  
   321  var _ = f8[int, float64](0, 0, nil...) // test case for #18268
   322  
   323  // init functions cannot have type parameters
   324  
   325  func init() {}
   326  func init[_ /* ERROR func init must have no type parameters */ any]() {}
   327  func init[P /* ERROR func init must have no type parameters */ any]() {}
   328  
   329  type T struct {}
   330  
   331  func (T) m1() {}
   332  func (T) m2[ /* ERROR method must have no type parameters */ _ any]() {}
   333  func (T) m3[ /* ERROR method must have no type parameters */ P any]() {}
   334  
   335  // type inference across parameterized types
   336  
   337  type S1[P any] struct { f P }
   338  
   339  func f9[P any](x S1[P]) {}
   340  
   341  func _() {
   342          f9[int](S1[int]{42})
   343  	f9(S1[int]{42})
   344  }
   345  
   346  type S2[A, B, C any] struct{}
   347  
   348  func f10[X, Y, Z any](a S2[X, int, Z], b S2[X, Y, bool]) {}
   349  
   350  func _[P any]() {
   351          f10[int, float32, string](S2[int, int, string]{}, S2[int, float32, bool]{})
   352          f10(S2[int, int, string]{}, S2[int, float32, bool]{})
   353          f10(S2[P, int, P]{}, S2[P, float32, bool]{})
   354  }
   355  
   356  // corner case for type inference
   357  // (was bug: after instanting f11, the type-checker didn't mark f11 as non-generic)
   358  
   359  func f11[T any]() {}
   360  
   361  func _() {
   362  	f11[int]()
   363  }
   364  
   365  // the previous example was extracted from
   366  
   367  // For now, a lone type parameter is not permitted as RHS in a type declaration (issue #45639).
   368  // func f12[T interface{m() T}]() {}
   369  //
   370  // type A[T any] T
   371  //
   372  // func (a A[T]) m() A[T]
   373  //
   374  // func _[T any]() {
   375  // 	f12[A[T]]()
   376  // }
   377  
   378  // method expressions
   379  
   380  func (_ S1[P]) m()
   381  
   382  func _() {
   383  	m := S1[int].m
   384  	m(struct { f int }{42})
   385  }
   386  
   387  func _[T any] (x T) {
   388          m := S1[T].m
   389          m(S1[T]{x})
   390  }
   391  
   392  // type parameters in methods (generalization)
   393  
   394  // Type Parameter lists are not allowed on methods, and are not produced by
   395  // go/parser. The test cases below are preserved for consistency with types2,
   396  // which produces an error but stores type parameters.
   397  // type R0 struct{}
   398  
   399  // func (R0) _[ /* ERROR methods cannot have type parameters */ T any](x T) {}
   400  // func (R0 /* ERROR invalid receiver */ ) _[ /* ERROR methods cannot have type parameters */ R0 any]() {} // scope of type parameters starts at "func"
   401  
   402  // type R1[A, B any] struct{}
   403  
   404  // func (_ R1[A, B]) m0(A, B)
   405  // func (_ R1[A, B]) m1[ /* ERROR methods cannot have type parameters */ T any](A, B, T) T  { panic(0) }
   406  // func (_ R1 /* ERROR not a generic type */ [R1, _]) _()
   407  // func (_ R1[A, B]) _[ /* ERROR methods cannot have type parameters */ A /* ERROR redeclared */ any](B) {}
   408  
   409  // func _() {
   410  //         var r R1[int, string]
   411  //         r.m1[rune](42, "foo", 'a')
   412  //         r.m1[rune](42, "foo", 1.2 /* ERROR cannot use .* as rune .* \(truncated\) */)
   413  //         r.m1(42, "foo", 1.2) // using type inference
   414  //         var _ float64 = r.m1(42, "foo", 1.2)
   415  // }
   416  
   417  type I1[A any] interface {
   418          m1(A)
   419  }
   420  
   421  var _ I1[int] = r1[int]{}
   422  
   423  type r1[T any] struct{}
   424  
   425  func (_ r1[T]) m1(T)
   426  
   427  type I2[A, B any] interface {
   428          m1(A)
   429          m2(A) B
   430  }
   431  
   432  var _ I2[int, float32] = R2[int, float32]{}
   433  
   434  type R2[P, Q any] struct{}
   435  
   436  func (_ R2[X, Y]) m1(X)
   437  func (_ R2[X, Y]) m2(X) Y
   438  
   439  // type assertions and type switches over generic types
   440  // NOTE: These are currently disabled because it's unclear what the correct
   441  // approach is, and one can always work around by assigning the variable to
   442  // an interface first.
   443  
   444  // // ReadByte1 corresponds to the ReadByte example in the draft design.
   445  // func ReadByte1[T io.Reader](r T) (byte, error) {
   446  // 	if br, ok := r.(io.ByteReader); ok {
   447  // 		return br.ReadByte()
   448  // 	}
   449  // 	var b [1]byte
   450  // 	_, err := r.Read(b[:])
   451  // 	return b[0], err
   452  // }
   453  //
   454  // // ReadBytes2 is like ReadByte1 but uses a type switch instead.
   455  // func ReadByte2[T io.Reader](r T) (byte, error) {
   456  //         switch br := r.(type) {
   457  //         case io.ByteReader:
   458  //                 return br.ReadByte()
   459  //         }
   460  // 	var b [1]byte
   461  // 	_, err := r.Read(b[:])
   462  // 	return b[0], err
   463  // }
   464  //
   465  // // type assertions and type switches over generic types are strict
   466  // type I3 interface {
   467  //         m(int)
   468  // }
   469  //
   470  // type I4 interface {
   471  //         m() int // different signature from I3.m
   472  // }
   473  //
   474  // func _[T I3](x I3, p T) {
   475  //         // type assertions and type switches over interfaces are not strict
   476  //         _ = x.(I4)
   477  //         switch x.(type) {
   478  //         case I4:
   479  //         }
   480  //
   481  //         // type assertions and type switches over generic types are strict
   482  //         _ = p /* ERROR cannot have dynamic type I4 */.(I4)
   483  //         switch p.(type) {
   484  //         case I4 /* ERROR cannot have dynamic type I4 */ :
   485  //         }
   486  // }
   487  
   488  // type assertions and type switches over generic types lead to errors for now
   489  
   490  func _[T any](x T) {
   491  	_ = x /* ERROR cannot use type assertion */ .(int)
   492  	switch x /* ERROR cannot use type switch */ .(type) {
   493  	}
   494  
   495  	// work-around
   496  	var t interface{} = x
   497  	_ = t.(int)
   498  	switch t.(type) {
   499  	}
   500  }
   501  
   502  func _[T interface{~int}](x T) {
   503  	_ = x /* ERROR cannot use type assertion */ .(int)
   504  	switch x /* ERROR cannot use type switch */ .(type) {
   505  	}
   506  
   507  	// work-around
   508  	var t interface{} = x
   509  	_ = t.(int)
   510  	switch t.(type) {
   511  	}
   512  }
   513  
   514  // error messages related to type bounds mention those bounds
   515  type C[P any] interface{}
   516  
   517  func _[P C[P]] (x P) {
   518  	x.m /* ERROR x.m undefined */ ()
   519  }
   520  
   521  type I interface {}
   522  
   523  func _[P I] (x P) {
   524  	x.m /* ERROR type P has no field or method m */ ()
   525  }
   526  
   527  func _[P interface{}] (x P) {
   528  	x.m /* ERROR type P has no field or method m */ ()
   529  }
   530  
   531  func _[P any] (x P) {
   532  	x.m /* ERROR type P has no field or method m */ ()
   533  }
   534  

View as plain text