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

// Issue 7525: self-referential array types.

package main

var y struct { // GC_ERROR "initialization cycle: y refers to itself"
	d [len(y.d)]int // GCCGO_ERROR "array bound|typechecking loop|invalid array"

// Copyright 2012 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 p

// Only tested on amd64 because the test only makes sense
// on a 64 bit system, and it is platform-agnostic,
// so testing one suffices.

package p

import "runtime"

func f() { // GC_ERROR "stack frame too large"
	x := [][]int{1e9: []int{}}
	runtime.KeepAlive(x)

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

// Issue 2444

package main
func main() {
	var arr [1000200030]int   // GC_ERROR "type .* too large"
	arr_bkup := arr
	_ = arr_bkup

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

// Issue 7525: self-referential array types.

package main

var z struct { // GC_ERROR "initialization cycle: z refers to itself"
	e [cap(z.e)]int // GCCGO_ERROR "array bound|typechecking loop|invalid array"

	if (handle == NULL) {
		fprintf(stderr, "%s\n", dlerror());
		exit(EXIT_FAILURE);
	}

	if (verbose) {
		fprintf(stderr, "calling dlsym\n");
	}

	// Start some goroutines.
	fn = (void(*)(void))dlsym(handle, "RunGoroutines");
	if (fn == NULL) {
		fprintf(stderr, "%s\n", dlerror());
		exit(EXIT_FAILURE);
	}

	if (verbose) {

// errorcheck

// Copyright 2016 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 f

func f(x int /* // GC_ERROR "unexpected newline"

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

package p

func _() {
	var ch chan bool
	select {
	default:
	case <-ch { // GCCGO_ERROR "expected colon"
	}           // GC_ERROR "expected :"

// do not generate panics in Type Stringer.
// Does not compile.

package main

type I interface {
	int // ERROR "interface contains embedded non-interface|embedding non-interface type int requires"
}

func n() {
	(I) // GC_ERROR "is not an expression"
}

func m() {

		}
	}
	return nil
}

func checkStatus(cmd *command, err error) error {
	if err == nil {
		if cmd.want == failure {
			return cmdError(cmd, ErrUnexpectedSuccess)
		}
		return nil
	}

	if s := (stopError{}); errors.As(err, &s) {
		// This error originated in the Stop command.
		// Propagate it as-is.
		return cmdError(cmd, err)
	}

	if w := (waitError{}); errors.As(err, &w) {