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

// Issue 38515: failed to mark the method wrapper
// reflect.Type.Method itself as REFLECTMETHOD.

package main

import "reflect"

var called bool

type foo struct{}

func (foo) X() { called = true }

var h = reflect.Type.Method

func main() {
	v := reflect.ValueOf(foo{})
	m := h(v.Type(), 0)
	f := m.Func.Interface().(func(foo))
	f(foo{})
	if !called {

	// we use reflect to find all such references.
	if len(badNils) > 0 {
		exprType := reflect.TypeFor[ast.Expr]()
		exprSliceType := reflect.TypeFor[[]ast.Expr]()
		walk(f, func(n any) {
			if n == nil {
				return
			}
			v := reflect.ValueOf(n)
			if v.Type().Kind() != reflect.Pointer {
				return
			}
			if v.IsNil() {
				return
			}

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

// See issue 44207.

package main

import "reflect"

type S int

func (s S) M() {}

func main() {
	t := reflect.TypeOf(S(0))
	fn, ok := reflect.PointerTo(t).MethodByName("M")
	if !ok {
		panic("FAIL")
	}
	fn.Func.Call([]reflect.Value{reflect.New(t)})

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

package main

import "reflect"

func main() {
	a := &struct{ x int }{}
	b := &struct{ x int "" }{}

	ta := reflect.TypeOf(a)
	tb := reflect.TypeOf(b)

	// Ensure cmd/compile treats absent and empty tags as equivalent.
	a = b

	// Ensure package reflect treats absent and empty tags as equivalent.
	if !tb.AssignableTo(ta) {
		panic("fail")
	}

		GroupName:          GroupName,
		SchemeGroupVersion: SchemeGroupVersion,
		AddToScheme:        AddToScheme,
		AllowedTags: map[reflect.Type]bool{
			reflect.TypeOf(metav1.TypeMeta{}):              true,
			reflect.TypeOf(metav1.Duration{}):              true,
			reflect.TypeOf(logsapi.LoggingConfiguration{}): true,
		},
	}

	if err := componentconfigtesting.VerifyInternalTypePackage(pkginfo); err != nil {

	// runtime.timeTimer (exported for testing as TimeTimer)
	// must have time.Timer and time.Ticker as a prefix
	// (meaning those two must have the same layout).
	runtimeTimeTimer := reflect.TypeOf(runtime.TimeTimer{})

	check := func(name string, typ reflect.Type) {
		n1 := runtimeTimeTimer.NumField()
		n2 := typ.NumField()
		if n1 != n2+1 {
			t.Errorf("runtime.TimeTimer has %d fields, want %d (%s has %d fields)", n1, n2+1, name, n2)

package foo

// Escape analysis needs to treat the uintptr-typed reflect.*Header fields as pointers.

import (
	"reflect"
	"unsafe"
)

type immutableBytes []byte

// Bug was failure to leak param b.
func toString(b immutableBytes) string { // ERROR "leaking param: b$"
	var s string
	if len(b) == 0 {
		return s
	}

	strHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))

// Test that we can inline the receiver arguments for
// reflect.Value.UnsafeAddr/Pointer, even in checkptr mode.

package main

import (
	"reflect"
	"unsafe"
)

func main() {
	n := 10                      // ERROR "moved to heap: n"
	m := make(map[string]string) // ERROR "moved to heap: m" "make\(map\[string\]string\) escapes to heap"

	_ = unsafe.Pointer(reflect.ValueOf(&n).Elem().UnsafeAddr()) // ERROR "inlining call"

		println(i, "!= -0.1384615")
		panic(0)
	}

	c := *(*complex128)(unsafe.Pointer(&c0))
	if c != c0 {
		println(c, "!=", c)
		panic(0)
	}

	var a interface{}
	switch c := reflect.ValueOf(a); c.Kind() {
	case reflect.Complex64, reflect.Complex128:
		v := c.Complex()
		_, _ = complex128(v), true
	}

		return false, TagInteger, false, true
	}
	switch t.Kind() {
	case reflect.Bool:
		return false, TagBoolean, false, true
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return false, TagInteger, false, true
	case reflect.Struct:
		return false, TagSequence, true, true
	case reflect.Slice:
		if t.Elem().Kind() == reflect.Uint8 {
			return false, TagOctetString, false, true
		}