val bindingContext = analysisContext.analyze(destructuringDeclaration)

                for (entry in destructuringDeclaration.entries) {
                    val resolvedCall = bindingContext.get(BindingContext.COMPONENT_RESOLVED_CALL, entry)
                    collector.checkResolveCall(resolvedCall)
                }
            }

            psi.annotationEntries.mapNotNull { entry ->
                bindingContext[BindingContext.ANNOTATION, entry]
            }
        )
    }

    override val analysisContext: Fe10AnalysisContext get() = analysisSession.analysisContext

    override val entries: List<KtLocalVariableSymbol>
        get() = withValidityAssertion {
            psi.entries.map { entry ->

        for (entryDescriptor in enumDescriptor.unsubstitutedMemberScope.getContributedDescriptors()) {
            if (entryDescriptor is ClassDescriptor && entryDescriptor.kind == ClassKind.ENUM_ENTRY) {
                result += KtFe10DescEnumEntrySymbol(entryDescriptor, analysisContext)
            }
        }

        return result
    }

     * Example:
     *   import ... // scope1  FirExplicitSimpleImportingScope - enum entry: ExplicitSimpleImporting
     *   // scope2  FirPackageMemberScope - enum entry: PackageMember
     *   class Outer { // scope3  FirClassUseSiteMemberScope - enum entry: ClassUseSite
     *     class Inner { // scope4  FirClassUseSiteMemberScope or FirNestedClassifierScope - enum entry: ClassUseSite/NestedClassifier

    get() = when (kind) {
        ClassKind.CLASS, ClassKind.ENUM_CLASS, ClassKind.OBJECT, ClassKind.ENUM_ENTRY -> false
        else -> true
    }

internal fun DeclarationDescriptor.toKtSymbol(analysisContext: Fe10AnalysisContext): KtSymbol? {
    if (this is ClassDescriptor && kind == ClassKind.ENUM_ENTRY) {
        return KtFe10DescEnumEntrySymbol(this, analysisContext)
    }

    return when (this) {

            ?.unsubstitutedMemberScope
            ?.getContributedClassifier(entryName, NoLookupLocation.FROM_IDE)

        if (entryDescriptor is ClassDescriptor && entryDescriptor.kind == ClassKind.ENUM_ENTRY) {
            return KtFe10DescEnumEntrySymbol(entryDescriptor, analysisContext)
        }

        return null
    }

                        getExpectedType(whenExpression)?.let { return it }

                        val entries = whenExpression.entries
                        val entryExpressions = entries.mapNotNull { entry -> entry.expression?.takeUnless { expression == it } }
                        val kotlinTypes = entryExpressions.mapNotNull { analysisContext.analyze(it).getType(it) }

            token,
        )
    }
    add(FirErrors.DEPRECATED_ACCESS_TO_ENUM_ENTRY_COMPANION_PROPERTY) { firDiagnostic ->
        DeprecatedAccessToEnumEntryCompanionPropertyImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.DEPRECATED_ACCESS_TO_ENTRY_PROPERTY_FROM_ENUM) { firDiagnostic ->
        DeprecatedAccessToEntryPropertyFromEnumImpl(

        fun buildAnonymousObjectSymbol(symbol: FirAnonymousObjectSymbol): KtAnonymousObjectSymbol {
            return symbolsCache.cache(symbol) {
                when (symbol.classKind) {
                    ClassKind.ENUM_ENTRY -> KtFirEnumEntryInitializerSymbol(symbol, analysisSession)
                    else -> KtFirAnonymousObjectSymbol(symbol, analysisSession)
                }
            }
        }

        //   constructor()
        // }
        // class B: <caret>A()
        //
        // We want to resolve to the secondary constructor in A. Therefore, we check that the caret is at a supertype
        // call entry and if so we resolve the constructor callee expression.
        val userType = expression.parent as? KtUserType ?: return expression
        val typeReference = userType.parent as? KtTypeReference ?: return expression