?: ErrorUtils.createErrorType(ErrorTypeKind.IMPLICIT_RETURN_TYPE_FOR_FUNCTION, declaration.name ?: "<unknown>")

            return kotlinType.toKtType(analysisContext)
        }

        if (declaration is KtProperty) {
            val bindingContext = analysisContext.analyze(declaration)

                val bindingContext = analysisContext.analyze(expression)

                collector.checkResolveCall(bindingContext.get(BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL, expression.loopRange))
                collector.checkResolveCall(bindingContext.get(BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL, expression.loopRange))

        if (!isDelegate) return

        val bindingContext = analysisContext.analyze(property)
        val descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property)
        if (descriptor !is VariableDescriptorWithAccessors) return

        descriptor.accessors.forEach { accessor ->
            collector.checkResolveCall(bindingContext.get(BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL, accessor))
        }
    }

import org.jetbrains.kotlin.resolve.BindingContext

internal class KaFe10PsiAnonymousObjectSymbol(
    override val psi: KtObjectDeclaration,
    override val analysisContext: Fe10AnalysisContext
) : KaAnonymousObjectSymbol(), KaFe10PsiSymbol<KtObjectDeclaration, ClassDescriptor> {
    override val descriptor: ClassDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)

    fun getAnalysisContext(ktModule: KtModule, token: KaLifetimeToken): Fe10AnalysisContext

    fun analyze(elements: List<KtElement>, mode: AnalysisMode = AnalysisMode.FULL): BindingContext

    fun analyze(element: KtElement, mode: AnalysisMode = AnalysisMode.FULL): BindingContext {
        return analyze(listOf(element), mode)
    }

    fun getOrigin(file: VirtualFile): KaSymbolOrigin

    enum class AnalysisMode {

        val bindingContext = analysisContext.analyze(whenExpression)
        return WhenChecker.getMissingCases(whenExpression, bindingContext)
    }

    override fun isUsedAsExpression(expression: KtExpression): Boolean {
        val bindingContext = analysisContext.analyze(expression)
        return expression.isUsedAsExpression(bindingContext)
    }

    }

    override val generatedPrimaryConstructorProperty: KaKotlinPropertySymbol? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        val propertyDescriptor = bindingContext[BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, psi] ?: return@cached null

        KaFe10DescKotlinPropertySymbol(propertyDescriptor as PropertyDescriptorImpl, analysisContext)
    }

import org.jetbrains.kotlin.resolve.BindingContext

internal class KaFe10PsiLiteralAnonymousFunctionSymbol(
    override val psi: KtFunctionLiteral,
    override val analysisContext: Fe10AnalysisContext
) : KaAnonymousFunctionSymbol(), KaFe10PsiSymbol<KtFunctionLiteral, FunctionDescriptor> {
    override val descriptor: FunctionDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi)

        get() = analysisSession.token

    override fun evaluate(expression: KtExpression): KaConstantValue? {
        val bindingContext = analysisContext.analyze(expression)

        val constant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, bindingContext)

        // TODO: how to _not_ evaluate expressions with a compilation error, e.g., uninitialized property access

import org.jetbrains.kotlin.resolve.BindingContext

internal class KaFe10PsiPropertySetterSymbol(
    override val psi: KtPropertyAccessor,
    override val analysisContext: Fe10AnalysisContext
) : KaPropertySetterSymbol(), KaFe10PsiSymbol<KtPropertyAccessor, PropertySetterDescriptor> {
    override val descriptor: PropertySetterDescriptor? by cached {
        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)