if (firSymbol.fir.initializer == null) {
            return@cached null
        }

        firSymbol.fir.lazyResolveToPhase(FirResolvePhase.BODY_RESOLVE)

        val initializerExpression = firSymbol.fir.initializer
        check(initializerExpression is FirAnonymousObjectExpression) {
            "Unexpected enum entry initializer: ${initializerExpression?.javaClass}"
        }

    if (compileTimeInitializer != null) {
        return KaConstantInitializerValue(compileTimeInitializer.toKtConstantValue(), initializer)
    }
    if (initializer != null) {
        val bindingContext = analysisContext.analyze(initializer)
        val constantValue = ConstantExpressionEvaluator.getConstant(initializer, bindingContext)
        if (constantValue != null) {

            hasNext?.fir?.buildSymbol(firSymbolBuilder),
            next?.fir?.buildSymbol(firSymbolBuilder),
        )
    }

    private fun FirProperty.getInitializerFunctionCall() =
        (initializer as? FirFunctionCall)?.calleeReference?.getResolvedSymbolOfNameReference()

    override fun isReferenceToImportAlias(alias: KtImportAlias): Boolean {
        return super<KaFirReference>.isReferenceToImportAlias(alias)
    }

            getComponentNSymbol(fir)
        )
    }

    private fun KaFirSession.getComponentNSymbol(fir: FirProperty): KaSymbol? {
        val componentFunctionSymbol = (fir.initializer as? FirComponentCall)?.getCalleeSymbol() ?: return null
        return componentFunctionSymbol.fir.buildSymbol(firSymbolBuilder)
    }

    override fun isReferenceToImportAlias(alias: KtImportAlias): Boolean {

type Instance struct {
	TypeArgs *TypeList
	Type     Type
}

// An Initializer describes a package-level variable, or a list of variables in case
// of a multi-valued initialization expression, and the corresponding initialization
// expression.
type Initializer struct {
	Lhs []*Var // var Lhs = Rhs
	Rhs syntax.Expr
}

func (init *Initializer) String() string {
	var buf strings.Builder
	for i, lhs := range init.Lhs {

            initializer: (File) -> Unit
        ): File = try {
            executionEngineFor(scriptHost)
                .createRequest(
                    KotlinScriptCompilationAndInstrumentation(
                        programId,
                        compilationClassPath,
                        accessorsClassPath,
                        initializer,
                        classpathHasher,

        get() = withValidityAssertion { firSymbol.createKtTypeParameters(builder) }


    override val isExtension: Boolean get() = withValidityAssertion { firSymbol.isExtension }

    override val initializer: KaInitializerValue? by cached { firSymbol.getKtConstantInitializer(builder) }

    override val modality: Modality get() = withValidityAssertion { firSymbol.modality }

        get() = withValidityAssertion { field }
}

public typealias KtEnumEntryAnnotationValue = KaEnumEntryAnnotationValue

/**
 * Some constant value (which may be used as initializer of `const val`) used as annotation argument. It may be String literal, number literal or some simple expression.
 * E.g: `@A(1 +2, "a" + "b")` -- both arguments here are [KaConstantAnnotationValue]
 * @see [KaConstantValue]
 */

 *
 * <p>On different platforms AbstractFuture uses different strategies for its core synchronization
 * primitives. The strategies are all implemented as subtypes of AtomicHelper and the strategy is
 * selected in the static initializer of AbstractFuture. This is convenient and performant but
 * introduces some testing difficulties. This test exercises the two fallback strategies in abstract
 * future.
 *
 * <ul>

 *
 * <p>On different platforms AbstractFuture uses different strategies for its core synchronization
 * primitives. The strategies are all implemented as subtypes of AtomicHelper and the strategy is
 * selected in the static initializer of AbstractFuture. This is convenient and performant but
 * introduces some testing difficulties. This test exercises the two fallback strategies in abstract
 * future.
 *
 * <ul>