// https://golang.org/pkg/unsafe/#Pointer.

	switch x := astutil.Unparen(x).(type) {
	case *ast.SelectorExpr:
		// "(6) Conversion of a reflect.SliceHeader or
		// reflect.StringHeader Data field to or from Pointer."
		if x.Sel.Name != "Data" {
			break
		}
		// reflect.SliceHeader and reflect.StringHeader are okay,
		// but only if they are pointing at a real slice or string.
		// It's not okay to do:
		//	var x SliceHeader

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

// part two of issue 4124. Make sure reflect doesn't mark the field as exported.

package main

import "reflect"

var T struct {
	int
}

func main() {
	v := reflect.ValueOf(&T)
	v = v.Elem().Field(0)
	if v.CanSet() {
		panic("int should be unexported")
	}

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

package main

import (
	"reflect"

	_ "./a"
	"./b"
)

var V struct{ i int }

func main() {
	if got := reflect.ValueOf(b.V).Type().Field(0).PkgPath; got != "b" {
		panic(`PkgPath=` + got + ` for first field of b.V, want "b"`)
	}
	if got := reflect.ValueOf(V).Type().Field(0).PkgPath; got != "main" {

 * 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;

/**

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

package main

import (
	"./a"
	"reflect"
)

var s = []rune{0, 1, 2, 3}

func main() {
	m := map[any]int{}
	k := reflect.New(reflect.ArrayOf(4, reflect.TypeOf(int32(0)))).Elem().Interface()
	m[k] = 1
	a.F()

	f := frame.fn
	if f.args != abi.ArgsSizeUnknown {
		argMap.n = f.args / goarch.PtrSize
		return
	}
	// Extract argument bitmaps for reflect stubs from the calls they made to reflect.
	switch funcname(f) {
	case "reflect.makeFuncStub", "reflect.methodValueCall":
		// These take a *reflect.methodValue as their
		// context register and immediately save it to 0(SP).
		// Get the methodValue from 0(SP).

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

// Make sure return values are always scanned, when
// calling methods (+functions, TODO) with reflect.

package main

import (
	"reflect"
	"runtime/debug"
	"sync"
)

func main() {
	debug.SetGCPercent(1) // run GC frequently
	var wg sync.WaitGroup
	for i := 0; i < 20; i++ {
		wg.Add(1)
		go func() {

//
//	mockgen -source=pod_manager.go -destination=testing/mock_manager.go -package=testing Manager
//

// Package testing is a generated GoMock package.
package testing

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	v1 "k8s.io/api/core/v1"
	types "k8s.io/apimachinery/pkg/types"
	types0 "k8s.io/kubernetes/pkg/kubelet/types"
)

// MockManager is a mock of Manager interface.

limitations under the License.
*/

package conversion

import (
	"fmt"
	"reflect"
)

type typePair struct {
	source reflect.Type
	dest   reflect.Type
}

type NameFunc func(t reflect.Type) string

var DefaultNameFunc = func(t reflect.Type) string { return t.Name() }

// ConversionFunc converts the object a into the object b, reusing arrays or objects

		}

		for _, name := range []string{"Name", "Constraint"} {
			if reflect.ValueOf(result).FieldByName(name).Interface() != reflect.ValueOf(v).FieldByName(name).Interface() {
				t.Errorf(
					"check %v %v should equal, expects %v, got %v",
					k, name, reflect.ValueOf(result).FieldByName(name).Interface(), reflect.ValueOf(v).FieldByName(name).Interface(),
				)
			}
		}
	}
}