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? {

	// the given node. Note that for the node being evaluated, the passed nodeInfo
	// reference could be different from the one in NodeInfoSnapshot map (e.g., pods
	// considered to be running on the node could be different). For example, during
	// preemption, we may pass a copy of the original nodeInfo object that has some pods
	// removed from it to evaluate the possibility of preempting them to
	// schedule the target pod.

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

					},
				},
			},
			messageEvaluations: []cel.EvaluationResult{
				{
					EvalResult: celtypes.String("evaluated message"),
				},
			},
			policyDecision: []PolicyDecision{
				{
					Action:  ActionDeny,
					Message: "evaluated message",
					Reason:  forbiddenReason,
				},
			},
		},
		{
			name: "messageExpression for multiple validations",

type of a specially annotated switch expression.
The switch expression is evaluated exactly once in a switch statement.
</p>

<h4 id="Expression_switches">Expression switches</h4>

<p>
In an expression switch,
the switch expression is evaluated and
the case expressions, which need not be constants,
are evaluated left-to-right and top-to-bottom; the first one that equals the
switch expression

                        println("The parameter is `${taskParameter.get()}`")
                    }
                }

                // Expose dsl to the user, the value will be isolated only after settings has been fully evaluated
                extensions.create<my.SettingsPluginDsl>("dsl").let { dsl ->
                    gradle.lifecycle.beforeProject {
                        tasks.register<CustomTask>("test") {

			}
			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)
        }
    }

  // jsonPath is a simple JSON path which is evaluated against each custom resource to produce a
  // field selector value.
  // Only JSON paths without the array notation are allowed.
  // Must point to a field of type string, boolean or integer. Types with enum values
  // and strings with formats are allowed.
  // If jsonPath refers to absent field in a resource, the jsonPath evaluates to an empty string.
  // Must not point to metdata fields.