// 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 generics

func _[A, B any](a A, b B) int {}

func _[T any](x, y T) T

type T[P any] struct{}

type T[P1, P2, P3 any] struct{}

type T[P C] struct{}

type T[P1, P2, P3 C] struct{}

type T[P C[P]] struct{}

type T[P1, P2, P3 C[P1, P2, P3]] struct{}

func f[P any](x P)

func f[P1, P2, P3 any](x1 P1, x2 P2, x3 P3) struct{}

func f[P interface{}](x P)

func f[P1, P2, P3 interface{ m1(P1); ~P2|~P3 }](x1 P1, x2 P2, x3 P3) struct{}

func f[P any](T1[P], T2[P]) T3[P]

func (x T[P]) m()

func ((T[P])) m(x T[P]) P

func _() {

type _ []T[P]

var _ []T[P]

_ = []T[P]{}

}

// type constraint literals with elided interfaces

func _[P ~int, Q int | string]() {}

func _[P struct{f int}, Q *P]() {}

// various potentially ambiguous type parameter lists (issue #49482)

type _[P *T,] struct{}

type _[P T | T] struct{}

type _[P T | T | T | T] struct{}

type _[P *T, _ any] struct{}

type _[P (*T),] struct{}

type _[P ((*T)),] struct{}

type _[P ((~int)),] struct{}

type _[P (*T), _ any] struct{}

type _[P (T),] struct{}

type _[P (T), _ any] struct{}

type _[P *struct{}] struct{}

type _[P (*struct{})] struct{}

type _[P ([]int)] struct{}

// a type literal in an |-expression indicates a type parameter list (blank after type parameter list and type)

type _[P *[]int] struct{}

type _[P *T | T, Q T] struct{}

type _[P *[]T | T] struct{}

type _[P *T | T | T | T | ~T] struct{}

type _[P *T | T | T | ~T | T] struct{}

type _[P *T | T | struct{} | T] struct{}

type _[P <-chan int] struct{}

type _[P *T | struct{} | T] struct{}

// a trailing comma always indicates a (possibly invalid) type parameter list (blank after type parameter list and type)

type _[P *T,] struct{}

type _[P *T | T,] struct{}

type _[P *T | <-T | T,] struct{}

// slice/array type declarations (no blank between array length and element type)

type _ []byte

type _ [n]byte

type _ [P(T)]byte

type _ [P((T))]byte

type _ [P * *T]byte

type _ [P * T]byte

type _ [P(*T)]byte

type _ [P(**T)]byte

type _ [P * T - T]byte

type _ [P * T - T]byte

type _ [P * T | T]byte

type _ [P * T | <-T | T]byte

// equivalent test cases for potentially ambiguous type parameter lists, except

// for function declarations there is no ambiguity (issue #51548)

func _[P *T,]() {}

func _[P *T, _ any]() {}

func _[P (*T),]() {}

func _[P (*T), _ any]() {}

func _[P (T),]() {}

func _[P (T), _ any]() {}

func _[P *struct{}] () {}

func _[P (*struct{})] () {}

func _[P ([]int)] () {}

func _ [P(T)]() {}

func _ [P((T))]() {}

func _ [P * *T]() {}

func _ [P * T]() {}

func _ [P(*T)]() {}

func _ [P(**T)]() {}

func _ [P * T]() {}

func _[

P *T,

]() {}