}

public typealias KtLifetimeOwner = KaLifetimeOwner

public fun KaLifetimeOwner.isValid(): Boolean = token.isValid()

@Suppress("NOTHING_TO_INLINE")
public inline fun KaLifetimeOwner.assertIsValidAndAccessible() {
    token.assertIsValidAndAccessible()
}

public inline fun <R> KaLifetimeOwner.withValidityAssertion(action: () -> R): R {
    assertIsValidAndAccessible()
    return action()
}

/**

/**
 * Executes the given [action] in a [KaSession] context.
 *
 * The project will be analyzed from the perspective of [useSiteKtElement]'s module, also called the use-site module.
 *
 * @see KaSession
 */
public inline fun <R> analyze(
    useSiteKtElement: KtElement,
    action: KaSession.() -> R
): R =
    KaSessionProvider.getInstance(useSiteKtElement.project)
        .analyze(useSiteKtElement, action)

/**

        }
    }

    /**
     * Returns the list of files that contain all reached inline functions.
     */
    fun allFiles(): List<KtFile> = analyzedElements.mapTo(mutableSetOf()) { it.containingKtFile }.toList()

    /**
     * Returns the set of [KtObjectDeclaration]s which are defined as an object literal in one of the reached inline functions.
     */
    fun inlineObjectDeclarations(): Set<KtObjectDeclaration> {

// MODULE: context

// FILE: context.kt
fun test() {
    <caret_context>val x = 0
}

inline fun call(block: (Int) -> Int) {
    System.out.println(block(5))
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION

MODULE_FRAGMENT
  FILE fqName:<root> fileName:context.kt
    FUN name:call visibility:public modality:FINAL <> (block:kotlin.Function1<kotlin.Int, kotlin.Int>) returnType:kotlin.Unit [inline]
      VALUE_PARAMETER name:block index:0 type:kotlin.Function1<kotlin.Int, kotlin.Int>
      BLOCK_BODY
        CALL 'public open fun println (p0: kotlin.Int): kotlin.Unit declared in java.io.PrintStream' type=kotlin.Unit origin=null

            platform,
            kotlinCoreProjectEnvironment.project,
            mainModules,
        )
    }
}

@OptIn(ExperimentalContracts::class)
internal inline fun buildProjectStructureProvider(
    kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment,
    init: KtModuleProviderBuilder.() -> Unit,
): KtStaticProjectStructureProvider {
    contract {

            processor.invoke(symbol.fir)
            ProcessorAction.NEXT
        }
        else -> ProcessorAction.STOP
    }

    private inline fun <T : KaSymbol> processOverrides(
        callableSymbol: T,
        crossinline process: (FirTypeScope, FirDeclaration) -> Unit
    ) {
        if (callableSymbol !is KaCallableSymbol) {
            return

            append(namedValue.name)
            append(" = ")
            renderConstantValue(namedValue.expression)
            append(", ")
        }
    }

    private inline fun <E> StringBuilder.renderWithSeparator(
        collection: Collection<E>,
        separator: String,
        render: StringBuilder.(E) -> Unit
    ) {
        collection.forEachIndexed { index, element ->

    // Util function to avoid hard coding names of the classes. Type inference will do a better job figuring out the best type to cast to.
    // This visitor isn't type-safe anyway
    private inline fun <reified T> ContractDescriptionElement.accept() = accept(this@ContractDescriptionElementToAnalysisApi, Unit) as T

        conversions[diagnostic] = creator
    }

    private fun build() = KaDiagnosticConverter(conversions)

    companion object {
        inline fun buildConverter(init: KaDiagnosticConverterBuilder.() -> Unit) =
            KaDiagnosticConverterBuilder().apply(init).build()
    }