abstract fun convertExpression(expression: String, context: ConversionContext): String
    abstract fun convertType(type: KType): KType
    open val importsToAdd: List<String> get() = emptyList()
}

object HLIdParameterConversion : HLParameterConversion() {
    override fun convertExpression(expression: String, context: ConversionContext) = expression
    override fun convertType(type: KType): KType = type
}

            if (scope != null) {
                renderNamesContainedInScope(scope)
            } else {
                appendLine("NO_SCOPE")
            }
        }
    }

    companion object {
        private val renderer = KaDeclarationRendererForSource.WITH_QUALIFIED_NAMES.with {
            modifiersRenderer = modifiersRenderer.with {

 * work there. This functionality is covered by package scope tests.
 */
@OptIn(ExperimentalTopLevelDeclarationsGenerationApi::class)
internal object DeclarationsInPackageProvider {
    internal fun getTopLevelClassifierNamesInPackageProvider(packageFqName: FqName, analysisSession: KaFirSession): Set<Name> {
        return buildSet {
            addAll(

                is KtObjectDeclaration -> when {
                    psi.isCompanion() -> KaClassKind.COMPANION_OBJECT
                    psi.isObjectLiteral() -> KaClassKind.ANONYMOUS_OBJECT
                    else -> KaClassKind.OBJECT
                }
                is KtClass -> when {
                    psi.isInterface() -> KaClassKind.INTERFACE
                    psi.isEnum() -> KaClassKind.ENUM_CLASS

        }

        return KaFe10NeverRestoringSymbolPointer()
    }

    override fun equals(other: Any?): Boolean = isEqualTo(other)
    override fun hashCode(): Int = calculateHashCode()

    companion object {
        fun build(descriptor: FunctionDescriptor, analysisContext: Fe10AnalysisContext): KaFe10DescFunctionSymbol {
            return KaFe10DescFunctionSymbol(descriptor, analysisContext)
        }
    }

import org.jetbrains.kotlin.analysis.api.types.KaType
import org.jetbrains.kotlin.analysis.utils.printer.PrettyPrinter
import org.jetbrains.kotlin.analysis.utils.printer.prettyPrint
import org.jetbrains.kotlin.name.Name

internal object TestScopeRenderer {
    fun renderForTests(
        analysisSession: KaSession,
        scopeContext: KaScopeContext,
        printer: PrettyPrinter,
        printPretty: Boolean = false,

    }
}

public typealias KtType = KaType

public enum class KaTypeNullability(public val isNullable: Boolean) {
    NULLABLE(true),
    NON_NULLABLE(false),
    UNKNOWN(false);

    public companion object {
        public fun create(isNullable: Boolean): KaTypeNullability = if (isNullable) NULLABLE else NON_NULLABLE
    }
}

public typealias KtTypeNullability = KaTypeNullability

            }
        }

        return false
    }

    private class FirElementPathSearcher(statements: Collection<FirElement>) : FirDefaultVisitorVoid() {
        private companion object {
            val FORBIDDEN_FAKE_SOURCE_KINDS: Set<KtFakeSourceElementKind> = setOf(
                KtFakeSourceElementKind.WhenCondition,
                KtFakeSourceElementKind.SingleExpressionBlock
            )

                && overriddenDescriptors.isNotEmpty())
    }

internal val ClassDescriptor.isInterfaceLike: Boolean
    get() = when (kind) {
        ClassKind.CLASS, ClassKind.ENUM_CLASS, ClassKind.OBJECT, ClassKind.ENUM_ENTRY -> false
        else -> true
    }

internal fun DeclarationDescriptor.toKtSymbol(analysisContext: Fe10AnalysisContext): KaSymbol? {

- [`KT-65093`](https://youtrack.jetbrains.com/issue/KT-65093) K2: Super constructor call able to access uninitialized object fields
- [`KT-56489`](https://youtrack.jetbrains.com/issue/KT-56489) K2 allows reading uninitialized variable in object declaration
- [`KT-59987`](https://youtrack.jetbrains.com/issue/KT-59987) K2: Disappeared REIFIED_TYPE_FORBIDDEN_SUBSTITUTION