override val hasBody: Boolean
        get() = withValidityAssertion { descriptor.hasBody() }

    override val valueParameters: List<KtValueParameterSymbol>
        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion { true }

    override val callableIdIfNonLocal: CallableId?

            }
        }

        val typeContext = rootModuleSession.typeContext
        val coneType = typeContext.createSimpleType(
            lookupTag,
            builder.arguments.map { it.coneTypeProjection },
            builder.nullability.isNullable
        ) as ConeClassLikeType

        return coneType.asKtType() as KtClassType
    }

        val bindingContext = analysisContext.analyze(element, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
        val diagnostics = bindingContext.diagnostics.forElement(element)
        return diagnostics.map { KtFe10Diagnostic(it, token) }
    }

    override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> {
        val bindingContext = analysisContext.analyze(ktFile)

        val smartCastType = when (val smartCastType = bindingContext[BindingContext.SMARTCAST, expression]) {
            is SingleSmartCast -> smartCastType.type
            is MultipleSmartCasts -> intersectWrappedTypes(smartCastType.map.values)
            else -> null
        }
        val kotlinType = smartCastType ?: expression.getType(bindingContext) ?: analysisContext.builtIns.unitType
        return kotlinType.toKtType(analysisContext)
    }

        return scope
            .getContributedDescriptors(kindFilter = DescriptorKindFilter.FUNCTIONS)
            .asSequence()
            .filterIsInstance<ConstructorDescriptor>()
            .map { it.toKtConstructorSymbol(analysisContext) }
    }

}

internal open class KtFe10ScopeMember(
    override val scope: MemberScope,
    private val constructors: Collection<ConstructorDescriptor>,

            firDiagnostic.c.map { coneKotlinType ->
                firSymbolBuilder.typeBuilder.buildKtType(coneKotlinType)
            },
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.AMBIGUOUS_SUPER) { firDiagnostic ->
        AmbiguousSuperImpl(
            firDiagnostic.a.map { coneKotlinType ->

    }

    fun getAllConverters(conversionForCollectionValues: HLParameterConversion): Map<KClass<*>, HLParameterConversion> {
        return buildMap {
            putAll(typeMapping)
            put(
                Map::class,
                HLMapParameterConversion(
                    "key",
                    "value",

        return element.getDiagnostics(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }
    }

    override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> =
        ktFile.collectDiagnosticsForFile(firResolveSession, filter.asLLFilter()).map { it.asKtDiagnostic() }


    private fun KtDiagnosticCheckerFilter.asLLFilter() = when (this) {

                    KtClassTypeQualifier.KtResolvedClassTypeQualifier(
                        innerType.classDescriptor.toKtClassSymbol(analysisContext),
                        innerType.arguments.map { it.toKtTypeProjection(analysisContext) },
                        token
                    )
                }

            }
        }

    override val classId: ClassId

                    overriddenElement,
                    callableSymbol.analysisSession.useSiteSession
                )
            }
        }

        return overriddenElement.map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it) }
    }

    override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {