val testKlib = KtTestUtil.tmpDir("testLibrary").resolve("library.klib").toPath()

    val arguments = buildList {
        ktFiles.mapTo(this) { it.absolutePathString() }
        addAll(listOf("-produce", "library"))
        addAll(listOf("-output", testKlib.absolutePathString()))
    }

    val compileResult = callCompilerWithoutOutputInterceptor(arguments.toTypedArray())

    check(compileResult.exitCode == ExitCode.OK) {

            appendLine(innerExpression.withIndent(context.increaseIndent()))
            append("}".withIndent(context))
        }
    }

    override fun convertType(type: KType): KType =
        List::class.createType(
            arguments = listOf(
                KTypeProjection(
                    variance = KVariance.INVARIANT,
                    type = type.arguments.single().type?.let(mappingConversion::convertType)
                )

                    for (allowErrorTypes in listOf(false, true)) {
                        for (typeMappingMode in KaTypeMappingMode.entries) {
                            for (isAnnotationMethod in listOf(false, true)) {
                                val psiType = returnType.asPsiType(psiContext, allowErrorTypes, typeMappingMode, isAnnotationMethod)

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


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

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION
listOf(1, 2, 3, 4, 5)
    .filter { (it % 2) == 0 }
    .map { it * 2 }

import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.util.OperatorNameConventions

val kotlinFunctionInvokeCallableIds = (0..23).flatMapTo(hashSetOf()) { arity ->
    listOf(
        CallableId(StandardNames.getFunctionClassId(arity), OperatorNameConventions.INVOKE),
        CallableId(StandardNames.getSuspendFunctionClassId(arity), OperatorNameConventions.INVOKE)
    )

            declaration.getSymbol()
        }

        return SymbolsData(
            allDeclarationSymbols,
            listOf(ktFile.getFileSymbol()),
        )
    }

            ktFile, testServices.moduleStructure.modules.first(),
            KtDeclaration::class
        ) as KtDeclaration
        val symbol = declaration.getSymbol()
        return SymbolsData(listOf(symbol))
    }

                    KaClassKind.CLASS -> listOf(KtTokens.CLASS_KEYWORD)
                    KaClassKind.ENUM_CLASS -> listOf(KtTokens.ENUM_KEYWORD, KtTokens.CLASS_KEYWORD)
                    KaClassKind.ANNOTATION_CLASS -> listOf(KtTokens.ANNOTATION_KEYWORD, KtTokens.CLASS_KEYWORD)
                    KaClassKind.OBJECT -> listOf(KtTokens.OBJECT_KEYWORD)
                    KaClassKind.COMPANION_OBJECT -> listOf(KtTokens.COMPANION_KEYWORD, KtTokens.OBJECT_KEYWORD)

    override fun collectImportsForDiagnosticParameter(diagnosticParameter: HLDiagnosticParameter): Collection<String> = buildSet {
        diagnosticParameter.type.collectClassNamesTo(this)
    }

    override val defaultImports = listOf(
        "org.jetbrains.kotlin.analysis.api.diagnostics.KaDiagnosticWithPsi",
        "com.intellij.psi.PsiElement",
    )

    override fun collectImportsForDiagnosticParameter(diagnosticParameter: HLDiagnosticParameter): Collection<String> = buildSet {
        diagnosticParameter.type.collectClassNamesTo(this)
    }

    override val defaultImports = listOf(
        "org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic",
        "org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken",
    )