package typemap

import (
	"reflect"

	"istio.io/istio/pkg/ptr"
)

// TypeMap provides a map that holds a map of Type -> Value. There can be only a single value per type.
// The value stored for a type must be of the same type as the key.
type TypeMap struct {
	inner map[reflect.Type]any
}

func NewTypeMap() TypeMap {
	return TypeMap{make(map[reflect.Type]any)}
}

func Set[T any](t TypeMap, v T) {

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

// We were picking up a special noalg type from typelinks.

package main

import "reflect"

func f(m map[string]int) int {
	return m["a"]
}

func g(m map[[8]string]int) int {
	t := reflect.ArrayOf(8, reflect.TypeOf(""))
	a := reflect.New(t).Elem()
	return m[a.Interface().([8]string)]
}

func main() {
	m := map[[8]string]int{}
	g(m)

package json

import (
	"reflect"
	"testing"
)

func TestLookupPtrToStruct(t *testing.T) {
	type Elem struct {
		Key   string
		Value string
	}
	type Outer struct {
		Inner []Elem `json:"inner" patchStrategy:"merge" patchMergeKey:"key"`
	}
	outer := &Outer{}
	elemType, patchStrategies, patchMergeKey, err := LookupPatchMetadataForStruct(reflect.TypeOf(outer), "inner")
	if err != nil {
		t.Fatal(err)
	}

 * limitations under the License.
 */

package com.google.common.reflect;

import java.lang.reflect.GenericArrayType;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.ArrayList;
import java.util.EnumSet;
import junit.framework.TestCase;

/**

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

package main

import (
	"reflect"
)

type A[T any] struct {
	B[int]
}

type B[T any] struct {
}

func (b B[T]) Bat() {
	t := new(T)
	if tt := reflect.TypeOf(t); tt.Kind() != reflect.Pointer || tt.Elem().Kind() != reflect.Int {
		panic("unexpected type, want: *int, got: "+tt.String())
	}
}

type Foo struct {
	A[string]

import com.google.common.collect.Ordering;
import groovy.lang.GroovyObject;
import org.gradle.internal.reflect.GroovyMethods;
import org.gradle.internal.reflect.Types.TypeVisitResult;
import org.gradle.internal.reflect.Types.TypeVisitor;
import org.gradle.model.Managed;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

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

// Test that reflect.Value.UnsafeAddr/Pointer is handled
// correctly by -d=checkptr

package main

import (
	"reflect"
	"unsafe"
)

func main() {
	n := 10
	m := make(map[string]string)

	_ = unsafe.Pointer(reflect.ValueOf(&n).Elem().UnsafeAddr())
	_ = unsafe.Pointer(reflect.ValueOf(&m).Elem().Pointer())

// assigned to interfaces, but only if reflect.Type.Method is
// never used. Test it here.

package main

import "reflect"

var called = false

type M int

func (m M) UniqueMethodName() {
	called = true
}

var v M

type MyType interface {
	Method(int) reflect.Method
}

func main() {
	var t MyType = reflect.TypeOf(v)
	t.Method(0).Func.Interface().(func(M))(v)

package stdversion

import "reflect"

func main() {
	for _, t := range tests {
		runTest(reflect.ValueOf(t))
	}
}

func runTest(f reflect.Value) {
	xt := f.Type().In(0)
	st := f.Type().In(1)

	for _, x := range []int{1, 0, -1} {
		for _, s := range []int{-99, -64, -63, -32, -31, -16, -15, -8, -7, -1, 0, 1, 7, 8, 15, 16, 31, 32, 63, 64, 99} {
			args := []reflect.Value{
				reflect.ValueOf(x).Convert(xt),
				reflect.ValueOf(s).Convert(st),
			}
			if s < 0 {