// errorcheck

// 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 accepted by gccgo.

package main

type N string
type M string

const B N = "B"
const C M = "C"

func main() {
	q := B + C // ERROR "mismatched types|incompatible types"
	println(q)

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

//go:build gccgo

#include "_cgo_export.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* Test calling panic from C.  This is what SWIG does.  */

extern void _cgo_panic(const char *);
extern void *_cgo_allocate(size_t);

void
callPanic(void)
{

// compile

// Copyright 2015 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 10047: gccgo failed to compile a type switch where the switch variable
// and the base type of a case share the same identifier.

package main

func main() {
	type t int
	var p interface{}
	switch t := p.(type) {
	case t:
		_ = t
	}

[short] skip
[compiler:gccgo] skip # gccgo has no cover tool

# Test cover for a package that has an assembly function.

go test -outputdir=$WORK -coverprofile=cover.out coverasm
go tool cover -func=$WORK/cover.out
stdout '\tg\t*100.0%' # Check g is 100% covered.
! stdout '\tf\t*[0-9]' # Check for no coverage on the assembly function

-- go.mod --
module coverasm

go 1.16
-- p.go --
package p

func f()

func g() {

env GO111MODULE=off

# Coverage analysis should use 'set' mode by default,
# and should merge coverage profiles correctly.

[short] skip
[compiler:gccgo] skip # gccgo has no cover tool

go test -short -cover encoding/binary errors -coverprofile=$WORK/cover.out
! stderr '[^0-9]0\.0%'
! stdout '[^0-9]0\.0%'

grep -count=1 '^mode: set$' $WORK/cover.out
grep 'errors\.go' $WORK/cover.out
grep 'binary\.go' $WORK/cover.out

[!race] stop

// compile

// Copyright 2015 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 give an error:
// <built-in>: error: redefinition of ‘s$F$hash’
// <built-in>: note: previous definition of ‘s$F$hash’ was here
// <built-in>: error: redefinition of ‘s$F$equal’
// <built-in>: note: previous definition of ‘s$F$equal’ was here

package p

// errorcheck

// Copyright 2017 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 21770: gccgo incorrectly accepts "p.f = 0" where p is **struct

package p

type PP **struct{ f int }

func f() {
	// anonymous type
	var p **struct{ f int }
	p.f = 0 // ERROR "field"
	// named type
	var p2 PP
	p2.f = 0 // ERROR "field"

        GOROOT="/usr/local/go"
        GOSUMDB="sum.golang.org"
        GOTMPDIR=""
        GOTOOLDIR="/usr/local/go/pkg/tool/darwin_arm64"
        GOVCS=""
        GOVERSION="go1.20.7"
        GCCGO="gccgo"
        AR="ar"
        CC="clang"
        CXX="clang++"
        CGO_ENABLED="1"
        GOMOD="/dev/null"
        GOWORK=""
        CGO_CFLAGS="-O2 -g"
        CGO_CPPFLAGS=""

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

// PR61265: The gccgo middle-end failed to represent array composite literals
// where the elements are zero-sized values.
// This is a reduction of a program reported by GoSmith.

package p

var a = [1][0]int{B}[0]
var B = [0]int{}
var c = [1]struct{}{D}[0]

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

// Using the same name for a field in a composite literal and for a
// global variable that depends on the variable being initialized
// caused gccgo to erroneously report "variable initializer refers to
// itself".

package p

type S struct {
	F int
}

var V = S{F: 1}