failure.assertHasCause("Cannot run Project.afterEvaluate(Closure) when the project is already evaluated.")
    }

    @ToBeFixedForIsolatedProjects(because = "allprojects, evaluationDependsOn")
    def "shows deprecation warning when calling Project#afterEvaluate(Action) after the project was evaluated"() {
        buildFile '''
            allprojects { p ->
                println "[1] Adding afterEvaluate for $p.name"

import org.gradle.api.GradleException;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * This class keeps track of all objects being evaluated at the moment.
 * It helps to provide nicer error messages when the evaluation enters an endless cycle (A obtains a value of B which obtains a value of A).
 * <p>

                applyReflectionToJvmObjectConversion(step.evaluationSchemaForStep, step, stepContext.targetObject, topLevelObjectReflection)
                EvaluationResult.Evaluated(ConversionStepResult.ConversionSucceeded(analysisResult.stepResult))
            } else EvaluationResult.Evaluated(ConversionStepResult.ConversionNotApplicable(analysisResult.stepResult))
    }

    private
    fun <R : Any> applyReflectionToJvmObjectConversion(

        // - `allprojects` executes eagerly before any project has been evaluated, allowing its effects
        //   to be observable from other eager configuration blocks (e.g., `subprojects { ... }`).
        // - `lifecycle.beforeProject` executes just before each project is evaluated. Therefore, its effects
        //   are not observable from eager configuration blocks, which would anyway be incompatible with

        } else null
    }

    fun evaluateAsKtConstantValue(
        fir: FirElement,
    ): KaConstantValue? {
        val evaluated = evaluate(fir) ?: return null

        val value = evaluated.value
        val psi = evaluated.psi as? KtElement
        return when (evaluated.kind) {
            ConstantValueKind.Byte -> KaConstantValue.KaByteConstantValue(value as Byte, psi)

 *
 * @since 8.8
 */
@Incubating
public interface GradleLifecycle {
    /**
     * Adds an {@link IsolatedAction isolated action} to be called immediately before a project is evaluated.
     *
     * Any extensions added to the {@code Project} model will be available to build scripts.
     *
     * @param action The action to execute.
     * @see IsolatedAction for the requirements to isolated actions

import org.gradle.internal.declarativedsl.language.SingleFailureResult
import org.gradle.internal.declarativedsl.objectGraph.AssignmentTraceElement


sealed interface EvaluationResult<out R : StepResult> {
    class Evaluated<R : StepResult>(val stepResult: R) : EvaluationResult<R>

    class NotEvaluated<R : StepResult>(
        val stageFailures: List<StageFailure>,

internal fun FirExpression.asKaInitializerValue(builder: KaSymbolByFirBuilder, forAnnotationDefaultValue: Boolean): KaInitializerValue {
    val ktExpression = psi as? KtExpression
    val evaluated = FirCompileTimeConstantEvaluator.evaluateAsKtConstantValue(this)

    return when (evaluated) {
        null -> if (forAnnotationDefaultValue) {
            val annotationConstantValue = FirAnnotationValueConverter.toConstantValue(this, builder)

  // - 'params' - Parameter resource referred to by the policy binding being evaluated. Only populated if the policy has a ParamKind.
  // - 'namespaceObject' - The namespace object that the incoming object belongs to. The value is null for cluster-scoped resources.
  // - 'variables' - Map of composited variables, from its name to its lazily evaluated value.
  //   For example, a variable named 'foo' can be accessed as 'variables.foo'.

 *
 * <li>Finally, evaluate each <code>Project</code> by executing its <code>{@value #DEFAULT_BUILD_FILE}</code> file, if
 * present, against the project. The projects are evaluated in breadth-wise order, such that a project is evaluated
 * before its child projects. This order can be overridden by calling <code>{@link #evaluationDependsOnChildren()}</code> or by adding an