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

    "must have compile-time constant inputs and outputs.\n\n"
    "XLA compilation requires that operator arguments that represent shapes or "
    "dimensions be evaluated to concrete values at compile time.  This error "
    "means that a shape or dimension argument could not be evaluated at "
    "compile time, usually because the value of the argument depends on a "
    "parameter to the computation, on a variable, or on a stateful operation "

    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")) {

	variablesType.Fields["unused"] = apiservercel.NewDeclField("unused", apiservercel.StringType, true, nil, nil)
	variablesMap.Append("unused", func(_ *MapValue) ref.Val {
		t.Fatalf("unused variable must not be evaluated")
		return nil
	})

	exp = "variables.dict.a + ' ' + variables.dict.a + ' ' + variables.foo"
	v, err = compileAndRun(env, activation, exp)
	if err != nil {
		t.Fatalf("%q: %v", exp, err)
	}

            @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;

     * [com.intellij.psi.PsiElement] of initializer. May be null if property/variable came from non-source file.
     */
    public abstract val initializerPsi: KtExpression?
}

/**
 * Initializer value which can be evaluated to constant. E.g, string value, number, null literal.
 *
 * For more info about constant values please see [official Kotlin documentation](https://kotlinlang.org/docs/properties.html#compile-time-constants]).
 */

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

 *
 * @since 8.8
 */
@ServiceScope(Scope.Build.class)
public interface DevelocityBuildLifecycleService {

    /**
     * Adds an action to be called immediately before a project is evaluated.
     * <p>
     * The action will be applied to all projects configured in the current build. Due to `Isolated Projects`, a particular build might only configure a subset of all projects.
     *

type ClaimsMapper interface {
	// EvalClaimMapping evaluates the given claim mapping expression and returns a EvaluationResult.
	// This is used for username, groups and uid claim mapping that contains a single expression.
	EvalClaimMapping(ctx context.Context, claims *unstructured.Unstructured) (EvaluationResult, error)
	// EvalClaimMappings evaluates the given expressions and returns a list of EvaluationResult.