package main

import (
	"log"
	"reflect"
	"sort"
)

func main() {
	const length = 257
	x := make([]int64, length)
	for i := 0; i < length; i++ {
		x[i] = int64(i) * 27644437 % int64(length)
	}

	isLessStatic := func(i, j int) bool {
		return x[i] < x[j]
	}

	isLessReflect := reflect.MakeFunc(reflect.TypeOf(isLessStatic), func(args []reflect.Value) []reflect.Value {
		i := args[0].Int()

	Go2(a);
	if (a[0] != 42) {
		abort();
	}
}
*/
import "C"

import (
	"reflect"
	"unsafe"
)

//export Go1
func Go1(p *C.int) {
	reflect.ValueOf(p).Elem().Set(reflect.ValueOf(C.int(42)))
}

//export Go2
func Go2(p *C.char) {
	a := (*[2]byte)(unsafe.Pointer(p))
	reflect.Copy(reflect.ValueOf(a[:1]), reflect.ValueOf(a[1:]))
}

func main() {
	C.C1()
	C.C2()

package callbacks

import (
	"reflect"

	"gorm.io/gorm"
)

func callMethod(db *gorm.DB, fc func(value interface{}, tx *gorm.DB) bool) {
	tx := db.Session(&gorm.Session{NewDB: true})
	if called := fc(db.Statement.ReflectValue.Interface(), tx); !called {
		switch db.Statement.ReflectValue.Kind() {
		case reflect.Slice, reflect.Array:
			db.Statement.CurDestIndex = 0
			for i := 0; i < db.Statement.ReflectValue.Len(); i++ {

import org.junit.Test
import kotlin.reflect.KCallable
import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KMutableProperty
import kotlin.reflect.KParameter
import kotlin.reflect.KProperty
import kotlin.reflect.KType
import kotlin.reflect.KTypeProjection
import kotlin.reflect.KVariance
import kotlin.reflect.KVisibility
import kotlin.reflect.full.createType

	return nil
}

func nativeTypeToCELType(t *testing.T, nativeType reflect.Type, field func(name string, declType *apiservercel.DeclType, required bool) *apiservercel.DeclField, fields func(fields ...*apiservercel.DeclField) map[string]*apiservercel.DeclField) *apiservercel.DeclType {
	switch nativeType {
	case reflect.TypeOf(""):
		return apiservercel.StringType
	case reflect.TypeOf([]string{}):

	t := elemPatchMetaFromStruct.T

	var elemType reflect.Type
	switch t.Kind() {
	// If t is an array or a slice, get the element type.
	// If element is still an array or a slice, return an error.
	// Otherwise, return element type.
	case reflect.Array, reflect.Slice:
		elemType = t.Elem()
		if elemType.Kind() == reflect.Array || elemType.Kind() == reflect.Slice {

	newtyp := getTypeUnlocked("int", reflect.TypeFor[int]())
	if newtyp != tInt.gobType() {
		t.Errorf("reregistration of %s got new type", newtyp.string())
	}
	newtyp = getTypeUnlocked("uint", reflect.TypeFor[uint]())
	if newtyp != tUint.gobType() {
		t.Errorf("reregistration of %s got new type", newtyp.string())
	}
	newtyp = getTypeUnlocked("string", reflect.TypeFor[string]())
	if newtyp != tString.gobType() {

import java.util.Locale
import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KMutableProperty
import kotlin.reflect.KProperty
import kotlin.reflect.KType
import kotlin.reflect.KVisibility
import kotlin.reflect.full.instanceParameter
import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.primaryConstructor

// This part only converts the interface to a reflect.Value.
func checkForNilValues(targetStruct any) error {
	v := reflect.ValueOf(targetStruct)
	e := v.Elem()
	err := checkForNil(e)
	if err != nil {
		return err
	}
	return nil
}

// Checks for nil values in a reflect.Value.
func checkForNil(e reflect.Value) error {
	switch e.Kind() {
	case reflect.Struct:
		for i := 0; i < e.NumField(); i++ {

// Test basic restrictions on type aliases.

package p

import (
	"reflect"
	. "reflect"
)

type T0 struct{}

// Valid type alias declarations.

type _ = T0
type _ = int
type _ = struct{}
type _ = reflect.Value
type _ = Value

type (
	A0 = T0
	A1 = int
	A2 = struct{}
	A3 = reflect.Value
	A4 = Value
	A5 = Value

	N0 A0
)