// Copyright 2011 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.

// type declarations

package test0

import "unsafe"

const pi = 3.1415

type (
	N undeclared /* ERROR "undeclared" */
	B bool
	I int32
	A [10]P
	T struct {
		x, y P
	}
	P *T
	R (*R)
	F func(A) I
	Y interface {
		f(A) I
	}
	S [](((P)))
	M map[I]F
	C chan<- I
)


type (
	p1 pi /* ERROR "not a package" */ .foo
	p2 unsafe.Pointer
)


type (
	Pi pi /* ERROR "not a type" */

	a /* DISABLED "illegal cycle" */ a
	a /* ERROR "redeclared" */ int

	// where the cycle error appears depends on the
	// order in which declarations are processed
	// (which depends on the order in which a map
	// is iterated through)
	b c
	c /* DISABLED "illegal cycle" */ d
	d e
	e b

	t *t

	U V
	V *W
	W U

	P1 *S2
	P2 P1

	S0 struct {
	}
	S1 struct {
		a, b, c int
		u, v, a /* ERROR "redeclared" */ float32
	}
	S2 struct {
		U // anonymous field
		// TODO(gri) recognize double-declaration below
		// U /* ERROR "redeclared" */ int
	}
	S3 struct {
		x S2
	}
	S4/* DISABLED "illegal cycle" */ struct {
		S4
	}
	S5 struct {
		S6
	}
	S6 /* DISABLED "illegal cycle" */ struct {
		field S7
	}
	S7 struct {
		S5
	}

	L1 []L1
	L2 []int

	A1 [10]int
	A2 /* DISABLED "illegal cycle" */ [10]A2
	A3 /* DISABLED "illegal cycle" */ [10]struct {
		x A4
	}
	A4 [10]A3

	F1 func()
	F2 func(x, y, z float32)
	F3 func(x, y, x /* ERROR "redeclared" */ float32)
	F4 func() (x, y, x /* ERROR "redeclared" */ float32)
	F5 func(x int) (x /* ERROR "redeclared" */ float32)
	F6 func(x ...int)

	I1 interface{}
	I2 interface {
		m1()
	}
	I3 interface {
		m1()
		m1 /* ERROR "redeclared" */ ()
	}
	I4 interface {
		m1(x, y, x /* ERROR "redeclared" */ float32)
		m2() (x, y, x /* ERROR "redeclared" */ float32)
		m3(x int) (x /* ERROR "redeclared" */ float32)
	}
	I5 interface {
		m1(I5)
	}
	I6 interface {
		S0 /* ERROR "non-interface" */
	}
	I7 interface {
		I1
		I1
	}
	I8 /* DISABLED "illegal cycle" */ interface {
		I8
	}
	I9 /* DISABLED "illegal cycle" */ interface {
		I10
	}
	I10 interface {
		I11
	}
	I11 interface {
		I9
	}

	C1 chan int
	C2 <-chan int
	C3 chan<- C3
	C4 chan C5
	C5 chan C6
	C6 chan C4

	M1 map[Last]string
	M2 map[string]M2

	Last int
)