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)

                KtContractReturnsSpecificValueEffectDeclaration(KtContractConstantValue(KtContractConstantType.NULL, analysisContext.token))
            ConstantReference.NOT_NULL -> KtContractReturnsNotNullEffectDeclaration(analysisContext.token)
            ConstantReference.WILDCARD -> KtContractReturnsSuccessfullyEffectDeclaration(analysisContext.token)
            is BooleanConstantReference -> KtContractReturnsSpecificValueEffectDeclaration(

    val owner: KtFe10DescFunctionSymbol,
) : KtValueParameterSymbol(), KtFe10Symbol {
    override val analysisContext: Fe10AnalysisContext
        get() = owner.analysisContext

    override val token: KtLifetimeToken
        get() = owner.token

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { KtSymbolOrigin.JS_DYNAMIC }

    override val psi: PsiElement?
        get() = withValidityAssertion { null }

            ?: KtFe10NeverRestoringSymbolPointer()
    }

    override val returnType: KtType
        get() = withValidityAssertion { owningProperty.returnType }

    override val token: KtLifetimeToken
        get() = owningProperty.token

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion {
            KtFe10AnnotationsList.create(fieldDescriptor?.annotations ?: Annotations.EMPTY, analysisContext)

internal open class KtFirDelegatingTypeScope(
    val firScope: FirContainingNamesAwareScope,
    private val builder: KtSymbolByFirBuilder,
) : KtTypeScope {
    override val token: KtLifetimeToken get() = builder.token

    private val allNamesCached by cached {
        getPossibleCallableNames() + getPossibleClassifierNames()
    }

internal class KtFe10OverrideInfoProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtOverrideInfoProvider(), Fe10KtAnalysisSessionComponent {
    override val token: KtLifetimeToken
        get() = analysisSession.token

    override fun isVisible(memberSymbol: KtCallableSymbol, classSymbol: KtClassOrObjectSymbol): Boolean  {

import org.jetbrains.kotlin.name.Name

internal class KtFirFileScope(
    private val owner: KtFirFileSymbol,
    private val builder: KtSymbolByFirBuilder
) : KtScope {
    override val token: KtLifetimeToken get() = builder.token

    private val allNamesCached by cached {
        _callableNames + _classifierNames
    }

    override fun getAllPossibleNames(): Set<Name> = withValidityAssertion { allNamesCached }

    override val visibility: Visibility
        get() = withValidityAssertion { propertyDescriptor.ktVisibility }

    override val annotationsList: KtAnnotationsList
        get() = withValidityAssertion { KtEmptyAnnotationsList(token) }

    override fun createPointer(): KtSymbolPointer<KtPropertySetterSymbol> = withValidityAssertion {
        KtFe10NeverRestoringSymbolPointer()
    }

    class DefaultKtValueParameterSymbol(

{
  "version": "1.0",
  "builds": [
    {
      "teamcity": {
        "configuration": "Kotlin_KotlinDev_SafeMerge",
        "url": "https://buildserver.labs.intellij.net",
        "token": "${space-safe-merge-kt}",
        "ssl-keystore": "BuildServer client"
      }
    }
  ]

) : KtSubstitutorFactory(), Fe10KtAnalysisSessionComponent {

    override fun buildSubstitutor(builder: KtSubstitutorBuilder): KtSubstitutor {
        if (builder.mappings.isEmpty()) return KtSubstitutor.Empty(token)
        TODO()
    }