else -> ConeIntersectionType(superTypes).asKtType()
                }
            } else {
                fir.resolvedType.asKtType()
            }
        }
        is FirVariableAssignment -> {
            if (fir.lValue.source?.psi == expression) {
                fir.lValue.resolvedType.asKtType()

                            evaluate(fir.explicitReceiver, mode)?.evaluateStringLength()
                        } else {
                            referredVariable.toLiteralExpression(mode)
                        }
                    }
                    is FirFieldSymbol -> referredVariable.toLiteralExpression(mode)
                    else -> null
                }
            }
            is FirLiteralExpression<*> -> {

                                ?: KtArrayAnnotationValue(emptyList(), sourcePsi, token)
                        else null
                    }

                    is FirEnumEntrySymbol -> {
                        KtEnumEntryAnnotationValue(resolvedSymbol.callableId, sourcePsi, token)
                    }

                    else -> null
                }
            }

            is FirPropertyAccessExpression -> {

            else -> error("unexpected KtUnaryExpression $unaryExpression")
        }
        val compoundAccess = KtCompoundAccess.IncOrDecOperation(operatorPartiallyAppliedSymbol, kind, precedence)
        return if (baseExpression is KtArrayAccessExpression) {
            createCompoundArrayAccessCall(context, baseExpression, compoundAccess, resolvedCalls)
        } else {

        get() = withValidityAssertion {
            if (descriptor.functionTypeKind.isReflectType) false
            else fe10Type.getReceiverTypeFromFunctionType() != null
        }

    override val receiverType: KtType?
        get() = withValidityAssertion {
            if (descriptor.functionTypeKind.isReflectType) null
            else fe10Type.getReceiverTypeFromFunctionType()?.toKtType(analysisContext)
        }

    val localTypes: List<ConeKotlinType> = if (isLocal(session)) listOf(this) else {
        typeArguments.mapNotNull {
            if (it is ConeKotlinTypeProjection && it.type.isLocal(session)) {
                it.type
            } else null
        }
    }
    val unavailableLocalTypes = localTypes.filterNot { it.isLocalButAvailableAtPosition(session, useSitePosition) }

            else -> declarationDescriptor is TypeParameterDescriptor
        }
    }

    override fun TypeConstructorMarker.asTypeParameter(): TypeParameterMarker {
        require(this is TypeConstructor)
        return when (this) {
            is NewTypeVariableConstructor -> originalTypeParameter!!
            else -> declarationDescriptor as TypeParameterDescriptor
        }
    }

                    if (resolvedSymbols.isEmpty()) {
                        unresolvedNames += qualifiedNameAsFqName.shortName()
                        emptyList()
                    } else {
                        resolvedSymbols.flatMap { toImportableFqNames(it, qualifiedNameAsFqName) }
                    }
                }
                importableNames.forEach { importableName ->

        }
    else ->
        false
}


private fun KtAnalysisSession.isSimpleVariableAccessCall(reference: KtReferenceExpression): Boolean =
    when (val resolution = reference.resolveCall()) {
        is KtSuccessCallInfo ->
            resolution.call is KtSimpleVariableAccessCall
        else ->
            false
    }

            @Suppress("USELESS_CAST") // Smart cast is only available in K2
            val contextModule = (positionModule as KtDanglingFileModule).contextModule
            firResolveSession.getSessionFor(contextModule)
        } else {
            firResolveSession.getSessionFor(positionModule)
        }

        val effectiveContainers = collectUseSiteContainers(position, firResolveSession).orEmpty()