// cannot be inlined, no matter how small it is.

func getcallerpc() uintptr
func getcallersp() uintptr

func pc() uintptr {
	return getcallerpc() + 1
}

func cpc() uintptr { // ERROR "can inline cpc"
	return pc() + 2
}

func sp() uintptr {
	return getcallersp() + 3
}

func csp() uintptr { // ERROR "can inline csp"
	return sp() + 4

		t.Fatal(err)
	}
	for fullName, reason := range notInlinedReason {
		t.Errorf("%s was not inlined: %s", fullName, reason)
	}
}

func collectInlCands(msgs string) map[string]struct{} {
	rv := make(map[string]struct{})
	lines := strings.Split(msgs, "\n")
	re := regexp.MustCompile(`^\S+\s+can\s+inline\s+(\S+)`)
	for _, line := range lines {
		m := re.FindStringSubmatch(line)
		if m != nil {

// Some derived-type expressions require the compiler to synthesize
// function literals to plumb sub-dictionaries appropriately.
// However, when these expressions are inlined, we were constructing
// the function literal bodies with the inline-adjusted positions
// instead of the original (inline-free) positions, which could lead
// to infinite loops when unwinding the stack.

package main

import "runtime"

func assert[_ any]() {
	panic(0)

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

}

// InnermostPos returns the innermost position corresponding to xpos,
// that is, the code that is inlined and that inlines nothing else.
// In the example for InlTree above, the code for println within h
// would have an innermost position with line number 12, whether
// h was not inlined, inlined into g, g-then-f, or g-then-f-then-main.
// This corresponds to what someone debugging main, f, g, or h might

 */
inline fun <reified T : Any> Project.configure(noinline configuration: T.() -> Unit): Unit =
    typeOf<T>().let { type ->
        // Find and configure extension
        extensions.findByType(type)?.let(configuration)
            ?: Factory {
                // Find and configure convention
                // Reflective look up to still support plugins that inlined this function once conventions will be removed

namespace mlir {
namespace TF {

inline constexpr char kStandardPipelineBefore[] = "standard_pipeline_before";
inline constexpr char kStandardPipelineAfter[] = "standard_pipeline_after";

// Runs all passes involved in transforming or optimizing an MLIR graph without
// any target specialization. When enable_logging is true, enables
// tensorflow::BridgeLogger. When enable_inliner is true, enables the inliner
// pass.
ABSL_DEPRECATED(

		},
		// function, inlined
		{
			func(buf []byte) int { return testTracebackGenericFnInlined[int](buf) },
			"testTracebackGenericFnInlined[...](",
		},
		// method, not inlined
		{
			x.M,
			"testTracebackGenericTyp[...].M(",
		},
		// method, inlined
		{
			func(buf []byte) int { return x.Inlined(buf) },
			"testTracebackGenericTyp[...].Inlined(",
		},
	}
	var buf [1000]byte

Xiaopeng Han <******@****.***> 1686841337 +0800

// Matches lines in genssa output that describe an inlined file.
// Note it expects an unadventurous choice of basename.
var sepRE = regexp.QuoteMeta(string(filepath.Separator))
var inlineLine *regexp.Regexp = regexp.MustCompile(`^#\s.*` + sepRE + `[-\w]+\.go:(\d+)`)

// this matches e.g.                                 #  /pa/inline-dumpxxxx.go:6