// compile

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

// gofrontend incorrectly gave an error for this code.

package p

type B bool

func main() {
	var v B = false
	if (true && true) && v {
	}

// errorcheck

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

// identifiers beginning with non-ASCII digits were incorrectly accepted.
// issue 11359.

package p

// run

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

package main

// This used to print 0, because x was incorrectly captured by value.

func f() (x int) {
	defer func() func() {
		return func() {
			println(x)
		}
	}()()
	return 42
}

func main() {
	f()

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
- 40801
releaseNotes:
- |
  **Fixed** an issue with where a `DestinationRule` applying to multiple services could incorrectly apply an unexpected `subjectAltNames` field.
- |

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

// selector expression resolves incorrectly for defined
// pointer types.

package main

type E struct{ f int }
type T struct{ E }

func (*T) f() int { return 0 }

type P *T
type PP **T

func main() {
	var x P

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

// Issue 7590: gccgo incorrectly traverses nested composite literals.

package p

type S struct {
	F int
}

var M = map[string]S{
	"a": { F: 1 },
}

var P = M["a"]

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

// The gccgo compiler had a bug: if one file in a package did a dot
// import, then an earlier file in the package would incorrectly
// resolve to the imported names rather than reporting undefined
// errors.

// 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 incorrectly give an error when compiling this.

package p

func F() (i int) {
	for first := true; first; first = false {
		i++
	}
	return

// 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 4545: untyped constants are incorrectly coerced
// to concrete types when used in interface{} context.

package main

import "fmt"

func main() {
	var s uint
	fmt.Println(1.0 + 1<<s) // ERROR "invalid operation|non-integer type|incompatible type"

}

func main() {
	debug.SetGCPercent(1)
	for i := 0; i < 100000; i++ {
		m := make(map[*T]struct{}, 0)
		for j := 0; j < 20; j++ {
			// During the call to mapassign_fast64, the key argument
			// was incorrectly treated as a uint64. If the stack was
			// scanned during that call, the only pointer to k was
			// missed, leading to *k being collected prematurely.
			k := new(T)
			m[k] = struct{}{}
		}
	}