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

// Use the functions in one.go so that the inlined
// forms get type-checked.

package two

import "./one"

func use() {
	_ = one.New(1)

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

// Use the functions in pkg2.go so that the inlined
// forms get type-checked.

package pkg3

import "./pkg2"

var x = pkg2.F()

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

// Triggers a double walk of the (inlined) switch in il

package p

func il(s string) string {
	switch len(s) {
	case 0:
		return "zero"
	case 1:
		return "one"
	}
	return s
}

func f() {
	var s string
	var as []string

// run

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

// Multiple inlined calls to a function that causes
// redundant address loads.

package main

func F(v [2]float64) [2]float64 {
	return [2]float64{v[0], v[1]}
}

func main() {
	a := F([2]float64{1, 2})
	b := F([2]float64{3, 4})
	println(a[0], a[1], b[0], b[1])

package main

var G func(int) int

//go:noinline
func callclo(q, r int) int {
	p := func(z int) int {
		G = func(int) int { return 1 }
		return z + 1
	}
	res := p(q) ^ p(r) // These calls to "p" will be inlined
	G = p
	return res
}

func main() {
	callclo(1, 2)

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

// Check correctness of various closure corner cases
// that are expected to be inlined

package a

func f() bool               { return true }

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

// Functions that the inliner exported incorrectly.

package one

type T int

// Issue 2678
func F1(T *T) bool { return T == nil }

// Issue 2682.
func F2(c chan int) bool { return c == (<-chan int)(nil) }

// Use of single named return value.
func F3() (ret []int) { return append(ret, 1) }

// Call of inlined method with blank receiver.
func (_ *T) M() int { return 1 }

                         parent_op->getOperands(), parent_op->getResultTypes(),
                         op->getAttrs(), op->getSuccessors());
    Operation* inlined = builder.create(state);

    parent_op->replaceAllUsesWith(inlined);
    parent_op->erase();
  }
  return success();
}

// Three instances of the rule to cover the three different types of
// TF::FakeQuant operators

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

// Issue #44344: a crash in DWARF scope generation (trying to
// scope the PCs of a function that was inlined away).

package main

func main() {
	pv := []int{3, 4, 5}
	if pv[1] != 9 {
		pv = append(pv, 9)
	}
	tryit := func() bool {
		lpv := len(pv)
		if lpv == 101 {
			return false
		}

    padding-left: 1em
}

.toc-inlined {
    padding-bottom: 1em
}

.toc-inlined .directory {
    border-left: 0
}

.toc-inlined .directory li {
    font-size: 1rem
}

.toc-inlined .directory ul {
    list-style-type: none !important;
    padding-left: 0;
    padding-bottom: 0;
    margin: 0
}

.toc-inlined .directory ul ul {
    padding-left: 1em
}