package main

import "fmt"

//go:registerparams
//go:noinline
func passStruct6(a Struct6) Struct6 {
	return a
}

type Struct6 struct {
	Struct1
}

type Struct1 struct {
	A, B, C uint
}

func main() {
	fmt.Println(passStruct6(Struct6{Struct1{1, 2, 3}}))

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))
	structs := make([]*myStruct, n)
	for i := 0; i < n; i++ {
		structs[i] = &myStruct{n: r.IntN(n)}
	}
	return structs
}

func TestStructSorts(t *testing.T) {
	ss := makeRandomStructs(200)
	ss2 := make([]*myStruct, len(ss))
	for i := range ss {

<!-- This is a new package; covered in 6-stdlib/3-structs.md. -->...

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

// issue 7366: generates a temporary with ideal type
// during comparison of small structs.

package main

type T struct {
	data [10]byte
}

func main() {
	var a T
	var b T
	if a == b {
	}

)

func bad() {
	var z = T{_: "verse"} // ERROR "invalid field name _ in struct initializer|expected struct field name|unknown field _ in struct literal of type T"
	_ = z
	_ = T{_: "itinerary"} // ERROR "invalid field name _ in struct initializer|expected struct field name|unknown field _ in struct literal of type T"

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

// Test pointers and the . (selector) operator on structs.

package main

type	x2	struct { a,b,c int; d int; };
var	g1	x2;
var	g2	struct { a,b,c int; d x2; };

func
main() {
	var x int;
	var s1 *x2;
	var s2 *struct { a,b,c int; d x2; };

	s1 = &g1;
	s2 = &g2;

	s1.a = 1;
	s1.b = 2;
	s1.c = 3;
	s1.d = 5;

	s2.a = 7;

// that are identified with an "apiVersion" and "kind" fields in their JSON
// serialization. It may be parameterized with the names of the fields in memory, or an
// optional list of base structs to search for those fields in memory.
type SimpleMetaFactory struct{}

// Interpret will return the APIVersion and Kind of the JSON wire-format
// encoding of an object, or an error.

	return len(x[i].index) < len(x[j].index)
}

// typeFields returns a list of fields that JSON should recognize for the given type.
// The algorithm is breadth-first search over the set of structs to include - the top struct
// and then any reachable anonymous structs.
func typeFields(t reflect.Type) []field {
	// Anonymous fields to explore at the current level and the next.
	current := []field{}
	next := []field{{typ: t}}

	{"&a10p[i]", func() { println(&a10p[i]) }},
	{"*structp", func() { use(*structp) }},
	{"&*structp", func() { println(&*structp) }},
	{"structp.i", func() { println(structp.i) }},
	{"&structp.i", func() { println(&structp.i) }},
	{"structp.j", func() { println(structp.j) }},
	{"&structp.j", func() { println(&structp.j) }},
	{"structp.k", func() { println(structp.k) }},
	{"&structp.k", func() { println(&structp.k) }},

// optional list of base structs to search for those fields in memory.
type SimpleMetaFactory struct {
}

// Interpret will return the APIVersion and Kind of the JSON wire-format
// encoding of an object, or an error.
func (SimpleMetaFactory) Interpret(data []byte) (*schema.GroupVersionKind, error) {
	findKind := struct {
		// +optional
		APIVersion string `json:"apiVersion,omitempty"`