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

// PR61248: Transformations to recover calls made them fail typechecking in gccgo.

package main

func main() {
	var f func(int, interface{})
	go f(0, recover())

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

// This directory contains a pair of packages that triggers a compiler
// error in gccgo (problem with the way inlinable call expressions are
// imported). See issue 32922 for details.

// run

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

// gccgo mishandled passing a struct with an empty field through
// reflect.Value.Call.

package main

import (
	"reflect"
)

type Empty struct {
	f1, f2 *byte
	empty struct{}
}

func F(e Empty, s []string) {
	if len(s) != 1 || s[0] != "hi" {

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

// Test converting a type defined in a different package to an
// interface defined in a third package, where the interface has a
// hidden method.  This used to cause a link error with gccgo.

package main

import (
	"./one"
	"./two"
)

func F(i1 one.I1) {
	switch v := i1.(type) {
	case two.S2:
		one.F1(v)
	}
}

func main() {
	F(nil)

// compile

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

// This code was incorrectly flagged as erroneous by gccgo.

package main

type Name string

type EFunc func(int) int

func Register(f EFunc, names ...Name) int {
	return f(len(names))
}

const (
	B Name = "B"
)

func RegisterIt() {

// compile

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

// gccgo mishandled embedded methods of type aliases.

package p

type I int

func (I) M() {}

type T = struct {
	I
}

func F() {
	_ = T.M
	_ = struct { I }.M

// compile

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

// PR61253: gccgo incorrectly parsed the
// `RecvStmt = ExpressionList "=" RecvExpr` production.

package main

func main() {
	c := make(chan int)
	v := new(int)
	b := new(bool)
	select {
	case (*v), (*b) = <-c:
	}

// compile

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

// Gccgo used to crash compiling this.

package p

type E int

func (e E) P() *E { return &e }

const (
	C1 E = 0
	C2 = C1
)

func F() *E {
	return C2.P()

// compile

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

// Valid program, gccgo reported an error.
// bug307.go:14:6: error: complex arguments must have identical types

package main

func main() {
	var f float64
	_ = complex(1/f, 0)

// errorcheck

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

// Issue 1927.
// gccgo failed to issue the first error below.

package main

func main() {
	println(int(1) == uint(1))	// ERROR "types"
	var x int = 1
	var y uint = 1
	println(x == y)			// ERROR "types"