token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalUnderscore

internal class ExpressionExpectedImpl(
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,
) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ExpressionExpected

internal class AssignmentInExpressionContextImpl(
    firDiagnostic: KtPsiDiagnostic,
    token: KtLifetimeToken,

                    index = null,
                    constructorSymbolPointer = null,
                    token = token
                ),
                token
            )
        }
        else -> {
            KtConstantAnnotationValue(toKtConstantValue(), token)
        }
    }
}

private class ClassLiteralResolutionResult(val type: KtType, val classId: ClassId)

    private val backingReceiverType: KtType?,
    private val backingValueParameters: List<KtVariableLikeSignature<KtValueParameterSymbol>>,
) : KtFunctionLikeSignature<S>() {
    override val token: KtLifetimeToken get() = backingSymbol.token
    override val symbol: S get() = withValidityAssertion { backingSymbol }
    override val returnType: KtType get() = withValidityAssertion { backingReturnType }

        if (lexicalScope != null) {
            val compositeScope = KtCompositeScope.create(listOf(KtFe10ScopeLexical(lexicalScope, analysisContext)), token)
            return KtScopeContext(listOf(KtScopeWithKind(compositeScope, scopeKind, token)), collectImplicitReceivers(lexicalScope), token)
        }

        val fileScope = analysisContext.resolveSession.fileScopeProvider.getFileResolutionScope(originalFile)

import org.jetbrains.kotlin.utils.exceptions.errorWithAttachment

internal class KtFirReferenceShortener(
    override val analysisSession: KtFirAnalysisSession,
    override val token: KtLifetimeToken,
    override val firResolveSession: LLFirResolveSession,
) : KtReferenceShortener(), KtFirAnalysisSessionComponent {
    private val context = FirShorteningContext(analysisSession)

                            ),
                            sourcePsi = null,
                            token
                        )
                    },
                    sourcePsi = null,
                    token
                ),
                token
            )
        )
    }.orEmpty()

    return toKtAnnotationApplication(builder, index, arguments)
}

    private val builder: KtSymbolByFirBuilder,
) : KtAnnotationsList() {
    private val useSiteSession: FirSession get() = builder.rootSession
    override val token: KtLifetimeToken get() = builder.token

    override val annotations: List<KtAnnotationApplicationWithArgumentsInfo>
        get() = withValidityAssertion {
            annotations(firCallableSymbol, builder, receiverParameter)
        }

    private val backingSymbol: S,
    private val backingReturnType: KtType,
    private val backingReceiverType: KtType?,
) : KtVariableLikeSignature<S>() {
    override val token: KtLifetimeToken get() = backingSymbol.token
    override val symbol: S get() = withValidityAssertion { backingSymbol }
    override val returnType: KtType get() = withValidityAssertion { backingReturnType }

                return when (calls.size) {
                    0 -> KtErrorCallInfo(listOf(KtQualifierCall(token, callExpression)), inapplicableCandidateDiagnostic(), token)
                    else -> KtErrorCallInfo(calls, inapplicableCandidateDiagnostic(), token)
                }
            }
        }

        if (this is FirImplicitInvokeCall) {

            token,
        )
    }
    add(FirErrors.NEW_INFERENCE_ERROR) { firDiagnostic ->
        NewInferenceErrorImpl(
            firDiagnostic.a,
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.OTHER_ERROR) { firDiagnostic ->
        OtherErrorImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }