return when (this) {
        is KtFe10PsiSymbol<*, *> -> descriptor
        is KtFe10DescSymbol<*> -> descriptor
        is KtFe10DescSyntheticFieldSymbol -> descriptor
        is KtFe10PsiDefaultPropertyGetterSymbol -> descriptor
        is KtFe10PsiDefaultPropertySetterSymbol -> descriptor
        is KtFe10PsiDefaultSetterParameterSymbol -> descriptor
        is KtFe10DescDefaultPropertySetterSymbol -> null

        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
            ?: return getEmptyScope()

        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, descriptor.constructors, analysisContext)
    }

    override fun getStaticMemberScope(symbol: KtSymbolWithMembers): KtScope {
        val descriptor = getDescriptor<ClassDescriptor>(symbol) ?: return getEmptyScope()

                    else -> {
                        val descriptor = unwrappedType.constructor.declarationDescriptor
                        if (descriptor is TypeParameterDescriptor) {
                            renderTypeParameterType(descriptor, printer)
                        } else if (descriptor is ClassifierDescriptorWithTypeParameters) {

import org.jetbrains.kotlin.config.ApiVersion
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.EffectiveVisibility
import org.jetbrains.kotlin.descriptors.Visibility

     *
     * This have a few caveats when it comes to the inner classes. TODO Provide a reference to some more in-detail description of that.
     *
     * @receiver A declaration that needs to be unwrapped.
     * @return An unsubstituted declaration ([originalForSubstitutionOverride]]) if it exists and if it does not have any change

                val bindingContext = analysisContext.analyze(parentExpression)
                val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, parentExpression]
                if (descriptor is CallableDescriptor) {
                    return descriptor.returnType?.toKtNonErrorType(analysisContext)
                }
            }

            is KtBinaryExpressionWithTypeRHS -> {

    }

    override fun getDispatchReceiverType(symbol: KtCallableSymbol): KtType? {
        require(symbol is KtFe10Symbol)
        val descriptor = symbol.getDescriptor() as? CallableDescriptor ?: return null
        return descriptor.dispatchReceiverParameter?.type?.toKtType(analysisContext)
    }

    override fun getArrayElementType(type: KtType): KtType? {
        require(type is KtFe10Type)

                    addAll(codeFragmentMappings.capturedValues)
                }
                for ((_, _, descriptor) in generationState.newFragmentCaptureParameters) {
                    if (descriptor is IrBasedDeclarationDescriptor<*>) {
                        addIfNotNull(computeAdditionalCodeFragmentMapping(descriptor))
                    }
                }
            }

        fun KtCall.isInBestCandidates(): Boolean {
            val descriptor = this.safeAs<KtFunctionCall<*>>()?.descriptor as? CallableDescriptor
            return descriptor != null && bestCandidateDescriptors.any { it ->
                DescriptorEquivalenceForOverrides.areCallableDescriptorsEquivalent(
                    it,
                    descriptor,
                    allowCopiesFromTheSameDeclaration = true,