if (this !is CallableMemberDescriptor || dispatchReceiverParameter != null) {
                    // Non-static open callables in final class are counted as final (to match FIR)
                    return Modality.FINAL
                }
            }
        }

        return this.modality
    }

internal fun ConstantValue<*>.toKtConstantValue(): KtConstantValue {

        return allowAnalysisOnEdt {
            allowAnalysisFromWriteAction {
                val resolveToPsiElements = try {
                    analyze(ref.expression) { ref.getResolvedToPsi(this) }
                } catch (e: Exception) {
                    if (shouldIjPlatformExceptionBeRethrown(e)) throw e

                    errorWithAttachment("Unable to resolve reference ${ref.element::class}", cause = e) {

            fir is FirPropertyAccessExpression || fir is FirExpression || fir is FirNamedReference -> {
                try {
                    FirCompileTimeConstantEvaluator.evaluateAsKtConstantValue(fir, mode)
                } catch (e: ArithmeticException) {
                    KtConstantValue.KtErrorConstantValue(e.localizedMessage, sourcePsi)
                }
            }
            // For invalid code like the following,
            // ```

            token,
        )
    }
    add(FirErrors.CATCH_PARAMETER_WITH_DEFAULT_VALUE) { firDiagnostic ->
        CatchParameterWithDefaultValueImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.REIFIED_TYPE_IN_CATCH_CLAUSE) { firDiagnostic ->
        ReifiedTypeInCatchClauseImpl(

### Klibs

- [`KT-62515`](https://youtrack.jetbrains.com/issue/KT-62515) Interop klib of concurrent version is not accepted when building dependent project: "The library versions don't match"

### Tools. CLI

- [`KT-63139`](https://youtrack.jetbrains.com/issue/KT-63139) Incorrect kotlin implementation version (1.9.255-SNAPSHOT) in metadata info

### Tools. Gradle

            else -> realPsi as? KtExpression
        }
    }

    private inline fun <R> wrapError(element: KtElement, action: () -> R): R {
        return try {
            action()
        } catch (e: Exception) {
            rethrowExceptionWithDetails(
                "Error during resolving call ${element::class}",
                exception = e,
            ) {

            // Throw expressions use the expression thrown.
            is KtThrowExpression ->
                parent.thrownExpression == child

            // Body and catch blocks of try-catch expressions are used if the try-catch itself
            // is used.
            is KtTryExpression ->
                (parent.tryBlock == child || child in parent.catchClauses) && isUsed(parent)

    return ((this as? KtQualifiedExpression)?.selectorExpression ?: this) as? KtSimpleNameExpression?
}

/**
 * Helper abstraction to navigate through qualified FIR elements - we have to match [ClassId] and PSI qualifier pair
 * to correctly reason about long qualifiers.
 */
private sealed interface TypeQualifier {
    val referencedClassId: ClassId

    /**

        val fir = expression.unwrap().getOrBuildFir(firResolveSession) ?: return null
        return try {
            getKtExpressionType(expression, fir)
        } catch (e: Exception) {
            rethrowExceptionWithDetails("Exception during resolving ${expression::class.simpleName}", e) {
                withPsiEntry("expression", expression)
                withFirEntry("fir", fir)