field := types.NewField(src.NoXPos, s, t)
	n := ir.NewNameAt(src.NoXPos, s, t)
	n.Class = which
	field.Nname = n
	return field
}

// mkstruct is a helper routine to create a struct type with fields
// of the types specified in 'fieldtypes'.
func mkstruct(fieldtypes ...*types.Type) *types.Type {
	fields := make([]*types.Field, len(fieldtypes))
	for k, t := range fieldtypes {
		if t == nil {

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package example1

type MyStruct struct {
	MyStructs []MyStruct
	MyStruct  *MyStruct

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

package main

import "fmt"

type myStruct struct {
	F0 [0]struct{}
	F1 float32
}

type myStruct2 struct {
	F0 [0]struct{}
	F1 float32
	F2 [0]struct{}
}

func main() {
	x := myStruct{F1: -1.25}
	fmt.Println(x)
	x2 := myStruct2{F1: -7.97}
	fmt.Println(x2)

// slices.SortFunc.
type myStruct struct {
	a, b, c, d string
	n          int
}

type myStructs []*myStruct

func (s myStructs) Len() int           { return len(s) }
func (s myStructs) Less(i, j int) bool { return s[i].n < s[j].n }
func (s myStructs) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func makeRandomStructs(n int) myStructs {
	r := rand.New(rand.NewPCG(42, 0))

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package example2

type MyStruct struct {
	MyStructs []MyStruct
	MyStruct  *MyStruct

		}
		return getFromStructPath(val.Index(idx).Interface(), path[1:])
	case reflect.Ptr:
		structElems = reflect.ValueOf(node).Elem()
		if !util.IsStruct(structElems) {
			return nil, false, fmt.Errorf("getFromStructPath path %s, expected struct ptr, got %T", path, node)
		}
	default:
		return nil, false, fmt.Errorf("getFromStructPath path %s, unsupported type %T", path, node)
	}

			}
		})
	}
}

type myStruct struct {
	a, b, c, d string
	n          int
}

func BenchmarkBinarySearchFuncStruct(b *testing.B) {
	for _, size := range []int{16, 32, 64, 128, 512, 1024} {
		b.Run(fmt.Sprintf("Size%d", size), func(b *testing.B) {
			structs := make([]*myStruct, size)
			for i := range structs {
				structs[i] = &myStruct{n: i}
			}
			midpoint := len(structs) / 2

package main

import (
	"fmt"
	"sync"
)

type MyStruct[T any] struct {
	val T
}

type Lockable[T any] struct {
	MyStruct[T]
	mu sync.Mutex
}

// Get returns the value stored in a Lockable.
func (l *Lockable[T]) Get() T {
	l.mu.Lock()
	defer l.mu.Unlock()
	return l.MyStruct.val
}

// Set sets the value in a Lockable.
func (l *Lockable[T]) Set(v T) {
	l.mu.Lock()

// via a type constraint.  (In this test, I -> IConstraint -> MyStruct -> I.)
type JsonRaw []byte

type MyStruct struct {
	x *I[JsonRaw]
}

type IConstraint interface {
	JsonRaw | MyStruct
}

type I[T IConstraint] struct {

package main

import "os"

var fail int

func check(b bool, msg string) {
	if (!b) {
		println("failure in", msg)
		fail++
	}
}

type I1 interface { Get() int; Put(int) }

type S1 struct { i int }
func (p S1) Get() int { return p.i }
func (p S1) Put(i int) { p.i = i }

func f1() {
	s := S1{1}
	var i I1 = s
	i.Put(2)
	check(i.Get() == 1, "f1 i")
	check(s.i == 1, "f1 s")
}