func f2[P1, P2 any, P3 any]() {}
func f3[P interface{}](x P, y T1[int]) {}

// function instantiations
var _ = f1[int]
var _ = f2[int, string, struct{}]
var _ = f3[bool]

// type parameters for types
type T1[P any] struct{}
type T2[P1, P2 any, P3 any] struct{}
type T3[P interface{}] interface{}

// type instantiations
type _ T1[int]
type _ T2[int, string, struct{}]
type _ T3[bool]

// methods

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

// Note: this doesn't really test the deduplication of
// instantiations. It just provides an easy mechanism to build a
// binary that you can then check with objdump manually to make sure
// deduplication is happening. TODO: automate this somehow?

// run

// Copyright 2022 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.

// The Go 1.18 frontend failed to disambiguate instantiations of
// different, locally defined generic types with the same name.
//
// The unified frontend also exposed the scope-disambiguation mangling
// to end users in reflect data.

package main

import (
	"reflect"
)

	// subset of the type set of the corresponding type parameter of T, meaning
	// that every instantiation of V corresponds to a valid instantiation of T.

	// Minor optimization: ensure we share a context across the two
	// instantiations below.
	if ctxt == nil {
		ctxt = types.NewContext()
	}

	var targs []types.Type
	for i := 0; i < vtparams.Len(); i++ {

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

// Testing that AddrTaken logic doesn't cause problems for function instantiations

package main

type A[T interface{ []int | [5]int }] struct {
	val T
}

//go:noinline
func (a A[T]) F() {
	_ = &a.val[2]
}

func main() {
	var x A[[]int]
	x.val = make([]int, 4)

		}()
	}
	_ = x.(A)
	if !shouldMatch {
		fmt.Printf("Should have panicked")
	}
}

func main() {
	// Test instantiation where the type switch/type asserts can't possibly succeed
	// (since string does not implement I[byte]).
	F[byte, string](S{}, false)

	// Test instantiation where the type switch/type asserts should succeed
	// (since S does implement I[byte])
	F[byte, S](S{}, true)
	F[byte, S](I[byte](S{}), true)

// license that can be found in the LICENSE file.

package a

type Value[T any] struct {
	val T
}

// The noinline directive should survive across import, and prevent instantiations
// of these functions from being inlined.

//go:noinline
func Get[T any](v *Value[T]) T {
	return v.val
}

//go:noinline
func Set[T any](v *Value[T], val T) {
	v.val = val
}

//go:noinline

type _[A interface{}] struct{}
type _[A, B interface{ m() }] struct{}

type _[A, B, C any] struct{}

// in functions
func _[P any]()
func _[P interface{}]()
func _[P B]()
func _[P B[P]]()

// type instantiations
type _ T[int]

// in expressions
var _ = T[int]{}

// in embedded types
type _ struct{ T[int] }

// interfaces
type _ interface {
	m()
	~int
}

type _ interface {

// the racecompile builder.
//
// This package is not imported so functions here are not included
// in the actual compiler.

// Issue 55357: data race when building multiple instantiations of
// generic closures with _ parameters.
func Issue55357() {
	type U struct {
		A int
		B string
		C string
	}
	var q T55357[U]
	q.Count()
	q.List()

	type M struct {
		A int64

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// correctness check: ensure that cycles through generic instantiations are detected
type T[P any] struct {
	_ P
}

type S /* ERROR "invalid recursive type" */ struct {
	_ T[S]
}

// simplified test 1

var _ A1[A1[string]]

type A1[P any] struct {
	_ B1[P]