if true {
	} else { // GCCGO_ERROR "block starts here"
	L:
	}
}

func _() {
	if false { // GCCGO_ERROR "block starts here"
	L:
	} else {
		goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
	}
}

func _() {
	if true {
		goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
	} else { // GCCGO_ERROR "block starts here"
	L:
	}

	f2 T2
}

type T2 struct { // GCCGO_ERROR "invalid recursive type"
	f1 T1
}

type a b // GCCGO_ERROR "invalid recursive type"
type b c // ERROR "invalid recursive type b\n\tLINE: b refers to\n\tLINE+1: c refers to\n\tLINE: b$|invalid recursive type"
type c b // GCCGO_ERROR "invalid recursive type"

type d e
type e f

type T struct{}

func (t *T) M(int, string)  // GCCGO_ERROR "previous"
func (t *T) M(int, float64) {} // ERROR "already declared|redefinition"

func (t T) H()  // GCCGO_ERROR "previous"
func (t *T) H() {} // ERROR "already declared|redefinition"

func f(int, string)  // GCCGO_ERROR "previous"
func f(int, float64) {} // ERROR "redeclared|redefinition"

func g(a int, b string) // GCCGO_ERROR "previous"

type S struct { // GC_ERROR "invalid recursive type"
	x interface{ S } // GCCGO_ERROR "interface"
}
type I4 interface { // GC_ERROR "invalid recursive type: I4 refers to itself"
	I4 // GCCGO_ERROR "interface"
}

type I5 interface { // GC_ERROR "invalid recursive type I5\n\tLINE:.* I5 refers to\n\tLINE+4:.* I6 refers to\n\tLINE:.* I5$"
	I6
}

type I6 interface {
	I5 // GCCGO_ERROR "interface"

	C interface{}
	Bar
}

type Bar struct {
	A string
}

func main() {
	_ = Foo{ // GCCGO_ERROR "too few expressions"
		1,
		2,
		3,
	} // GC_ERROR "too few values in"

	_ = Foo{
		1,
		2,
		3,
		Bar{"A", "B"}, // ERROR "too many values in|too many expressions"
	}

	_ = Foo{ // GCCGO_ERROR "too few expressions"
		1,
		2,
		Bar{"A", "B"}, // ERROR "too many values in|too many expressions"

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

package main

func main() {
	for x		// GCCGO_ERROR "undefined"
	{		// ERROR "unexpected {, expected for loop condition|expecting .*{.* after for clause"

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

package main

type T int

func (T) m() {} // GCCGO_ERROR "previous"
func (T) m() {} // ERROR "T\.m already declared|redefinition"

func (*T) p() {} // GCCGO_ERROR "previous"

package p

func _() {
	go func() {     // no error here about goroutine
		send <- // GCCGO_ERROR "undefined name"
	}()             // ERROR "expected expression|expected operand"
}

func _() {
	defer func() { // no error here about deferred function
		1 +    // GCCGO_ERROR "value computed is not used"
	}()            // ERROR "expected expression|expected operand"
}

func _() {

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

// Make sure we don't crash when reporting this error.

package p

func f() {
	if err := http.ListenAndServe( // GCCGO_ERROR "undefined name"

package p

type I1 = interface {
	I2
}

// BAD: type loop should mention I1; see also #41669
type I2 interface { // GC_ERROR "invalid recursive type: I2 refers to itself"
	I1 // GCCGO_ERROR "invalid recursive interface"