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

// Test that inlining a function literal that captures both a type
// switch case variable and another local variable works correctly.

package a

func F(p *int, x any) func() {
	switch x := x.(type) {
	case int:
		return func() {
			*p += x
		}
	}
	return nil

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

// Issue 35586: gollvm compiler crash building docker-ce; the problem
// involves inlining a function that has multiple no-name ("_") parameters.
//

// run

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

// Issue 4748.
// This program used to complain because inlining created two exit labels.

package main

func jump() {
        goto exit
exit:
        return
}
func main() {
        jump()
        jump()

// 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 3843: inlining bug due to wrong receive operator precedence.

package pkg2

import "./pkg1"

func F() {
	pkg1.Do()

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

// Issue 4323: inlining of functions with local variables
// forgets to typecheck the declarations in the inlined copy.

package main

type reader struct {
	C chan T
}

type T struct{ C chan []byte }

var r = newReader()

// compiledir

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

// Issue 5614: exported data for inlining may miss
// named types when used in implicit conversion to
// their underlying type.

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

package p

func F() { // ERROR "can inline"
	var v t
	v.m() // ERROR "inlining call"
}

type t int

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

package q

import "./p"

func H() {
	p.F() // ERROR "inlining call to p.F"
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
	print(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// compile

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

// Issue 15747: If an ODCL is dropped, for example when inlining,
// then it's easy to end up not initializing the '&x' pseudo-variable
// to point to an actual allocation. The liveness analysis will detect
// this and abort the computation, so this test just checks that the

// run

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

// issue 5515: miscompilation doing inlining in generated method wrapper

package main

type T uint32

func main() {
        b := make([]T, 8)
        b[0] = 0xdeadbeef
        rs := Slice(b)
        sort(rs)
}

type Slice []T