import org.slf4j.LoggerFactory


internal
inline fun <reified T : Any> loggerFor(): Logger =
    LoggerFactory.getLogger(T::class.java)


internal
inline fun Logger.trace(msg: () -> String) {
    if (isTraceEnabled) trace(msg())
}


internal
inline fun Logger.debug(msg: () -> String) {
    if (isDebugEnabled) debug(msg())
}


internal
inline fun Logger.info(msg: () -> String) {

        ).assertSameApi()
    }

    // test throws until we can detect lambdas in inline functions and treat them as ABI
    @Test(expected = CompileAvoidanceException::class)
    fun `changes to inline method bodies change generated API class`() {
        givenChangingClass(
            "Foo",
            """
                inline fun foo(): String {
                    return "foo"
                }
            """,

package main

func run() { // ERROR "cannot inline run: recursive"
	f := func() { // ERROR "can inline run.func1 with cost .* as:.*" "func literal does not escape"
		g() // ERROR "inlining call to g"
	}
	f() // ERROR "inlining call to run.func1" "inlining call to g"
	run()
}

func g() { // ERROR "can inline g with cost .* as:.*"
}

func main() { // ERROR "can inline main with cost .* as:.*"
	run()

//go:uintptrkeepalive
//go:nosplit
func explicit(uintptr) {
}

func autotmpImplicit() { // ERROR "can inline autotmpImplicit"
	var t int
	implicit(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to implicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
}

func autotmpExplicit() { // ERROR "can inline autotmpExplicit"
	var t int

            assertGeneratedExtensions(
                """
                inline fun org.gradle.kotlin.dsl.fixtures.codegen.ClassToKClass.`rawClass`(`type`: kotlin.reflect.KClass<*>): Unit =
                    `rawClass`(`type`.java)
                """,
                """
                inline fun org.gradle.kotlin.dsl.fixtures.codegen.ClassToKClass.`unknownClass`(`type`: kotlin.reflect.KClass<*>): Unit =

    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val isDefault: Boolean get() = withValidityAssertion { firSymbol.fir is FirDefaultPropertyAccessor }
    override val isInline: Boolean get() = withValidityAssertion { firSymbol.isInline }
    override val isOverride: Boolean
        get() = withValidityAssertion {
            if (firSymbol.isOverride) return true
            val propertySymbol = firSymbol.fir.propertySymbol

 * @return the created named object
 *
 * @see [ObjectFactory.newInstance]
 */
inline fun <reified T> ObjectFactory.newInstance(vararg parameters: Any): T =
    newInstance(T::class.java, *parameters)


/**
 * Creates a [Property] that holds values of the given type [T].
 *
 * @see [ObjectFactory.property]
 */
inline fun <reified T> ObjectFactory.property(): Property<T> =
    property(T::class.java)


/**

 *    119 : Ignored.
 *    120 : Valid.
 *    121 : Disallowed
 *    122 : Mapped inline to the sequence: [b2].
 *    123 : Mapped inline to the sequence: [b2a].
 *    124 : Mapped inline to the sequence: [b2, b3].
 *    125 : Mapped inline to the sequence: [b2a, b3].
 *    126 : Mapped inline to the sequence: [b2, b3a].
 *    127 : Mapped inline to the sequence: [b2a, b3a].
 *
 * The range goes until the beginning of the next range.
 *

ExtensionReceiver[name: dumbWith; isMutated: false; displayText: this@dumbWith]
    dumbWith@fun R|kotlin/Any?|.<anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>
    R|kotlin/Any?|
ExtensionReceiver[name: dumbWith; isMutated: false; displayText: this@dumbWith]
    dumbWith@fun R|kotlin/Any?|.<anonymous>(): R|kotlin/Unit| <inline=Inline, kind=UNKNOWN>

inline bool IsAllOnesConstant(Attribute value) {
  auto values = value.cast<DenseElementsAttr>().getValues<int32_t>();
  return !std::any_of(values.begin(), values.end(),
                      [](int32_t element_value) { return element_value != 1; });
}

// Checks if all elements in the constant attribute value are non-negative.
inline bool HasNonNegativeValues(Attribute value) {