// uninstantiated generic type.
func ConvertibleTo(V, T Type) bool {
	x := operand{mode: value, typ: V}
	return x.convertibleTo(nil, T, nil) // check not needed for non-constant x
}

// Implements reports whether type V implements interface T.
//
// The behavior of Implements is unspecified if V is Typ[Invalid] or an uninstantiated
// generic type.
func Implements(V Type, T *Interface) bool {

func (a *Alias) Underlying() Type { return unalias(a).Underlying() }

// Origin returns the generic Alias type of which a is an instance.
// If a is not an instance of a generic alias, Origin returns a.
func (a *Alias) Origin() *Alias { return a.orig }

// TypeParams returns the type parameters of the alias type a, or nil.
// A generic Alias and its instances have the same type parameters.

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

package cgotest

// #include <stddef.h>
import "C"

func generic[T, U any](t T, u U) {}

func useGeneric() {
	const zero C.size_t = 0

	generic(zero, zero)
	generic[C.size_t, C.size_t](0, 0)

package main

var decOps = []opData{}

var decBlocks = []blockData{}

func init() {
	archs = append(archs, arch{
		name:    "dec",
		ops:     decOps,
		blocks:  decBlocks,
		generic: true,
	})

	dup("package p; type _ [P * T | T]byte"),
	dup("package p; type _ [P * T | <-T | T]byte"),

	// generic function declarations
	dup("package p; func _[T any]()"),
	dup("package p; func _[A, B, C interface{m()}]()"),
	dup("package p; func _[T any, A, B, C interface{m()}, X, Y, Z interface{~int}]()"),

	// generic functions with elided interfaces in type constraints
	dup("package p; func _[P *T]() {}"),

For details see the [language spec](/ref/spec#For_statements).

<!-- go.dev/issue/46477, CL 566856, CL 586955, CL 586956 -->
Go 1.23 includes preview support for [generic type aliases](/issue/46477).

	// Needs to be a separate phase because it must run after both
	// lowering and a subsequent dead code elimination (because lowering
	// rules may leave dead generic ops behind).
	for _, b := range f.Blocks {
		for _, v := range b.Values {
			if !opcodeTable[v.Op].generic {
				continue // lowered
			}
			switch v.Op {

The methods [Alias.Origin], [Alias.SetTypeParams], [Alias.TypeParams],

		//	callee: "mult.MultClosure.func1",
		//},
	}

	testPGODevirtualize(t, dir, want, preProfFileName)
}

// Regression test for https://go.dev/issue/65615. If a target function changes
// from non-generic to generic we can't devirtualize it (don't know the type
// parameters), but the compiler should not crash.
func TestLookupFuncGeneric(t *testing.T) {
	wd, err := os.Getwd()
	if err != nil {

package test

import (
	"internal/testenv"
	"os"
	"path/filepath"
	"regexp"
	"testing"
)

// TestInst tests that only one instantiation of Sort is created, even though generic
// Sort is used for multiple pointer types across two packages.
func TestInst(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	testenv.MustHaveGoRun(t)

	// Build ptrsort.go, which uses package mysort.
	var output []byte