if (evaluator instanceof TypeAwareExpressionEvaluator) {
                    result = ((TypeAwareExpressionEvaluator) evaluator).evaluate(value, type);
                } else {
                    result = evaluator.evaluate(value);
                }
            }
            if (null == result && configuration.getChildCount() == 0) {
                value = configuration.getAttribute("default-value");

import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
import org.jetbrains.kotlin.types.TypeUtils


internal class KaFe10CompileTimeConstantProvider(
    override val analysisSession: KaFe10Session
) : KaCompileTimeConstantProvider(), KaFe10SessionComponent {
    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun evaluate(expression: KtExpression): KaConstantValue? {

import org.jetbrains.kotlin.analysis.api.components.KaCompileTimeConstantProvider
import org.jetbrains.kotlin.analysis.api.fir.KaFirSession
import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirAnnotationValueConverter
import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirCompileTimeConstantEvaluator
import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir

    public ArchRule as(String newDescription) {
        return new FreezeInstructionsPrintingArchRule(delegate.as(newDescription));
    }

    @Override
    public EvaluationResult evaluate(JavaClasses classes) {
        try {
            return delegate.evaluate(classes);
        } catch (RuntimeException e) {
            if (e.getMessage().contains("freeze.store")) {

        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                validateCustomProperties();
                System.getProperties().putAll(customProperties);
                try {
                    base.evaluate();
                } finally {
                    System.setProperties(properties);
                }
            }

			}
			if c.filter != nil {
				okay, err := c.filter.Evaluate(ctx, instance.Instance.Attributes)
				if err != nil {
					return nil, fmt.Errorf("evaluate filter CEL expression: %w", err)
				}
				if !okay {
					continue
				}
			}
			okay, err := request.Evaluate(ctx, instance.Instance.Attributes)
			if err != nil {
				return nil, fmt.Errorf("evaluate request CEL expression: %w", err)
			}
			if !okay {

    private val controller: ConfigurationCacheFingerprintController
) : ProjectEvaluator {
    override fun evaluate(project: ProjectInternal, state: ProjectStateInternal) {
        controller.runCollectingFingerprintForProject(project.identityPath) {
            delegate.evaluate(project, state)
        }
    }

    ExpectingFailureRuleStatement(Statement next, String feature) {
        this.next = next
        this.feature = feature
    }

    @Override
    void evaluate() throws Throwable {
        try {
            next.evaluate()
            throw new ToBeFixedSpecInterceptor.UnexpectedSuccessException(feature)
        } catch (ToBeFixedSpecInterceptor.UnexpectedSuccessException ex) {
            throw ex

            @Override
            public void evaluate() throws Throwable {
                ExpectedFailure expectedFailureAnnotation = method.getAnnotation(ExpectedFailure.class);
                boolean expectedToFail = expectedFailureAnnotation != null;
                Throwable failed = null;
                try {
                    base.evaluate();
                } catch (Throwable t) {
                    failed = t;

        if (map == null || map.isEmpty() || matchExpression == null) {
            return false;
        }

        final Object value = ComponentUtil.getScriptEngineFactory().getScriptEngine(scriptType).evaluate(matchExpression, map);
        if (value instanceof Boolean) {
            return ((Boolean) value);
        }

        return false;
    }

    public float getValue(final Map<String, Object> map) {