*
     * @param project The which is to be evaluated. Never null.
     */
    void beforeEvaluate(Project project);

    /**
     * <p>This method is called when a project has been evaluated, and before the evaluated project is made available to
     * other projects.</p>
     *
     * @param project The project which was evaluated. Never null.

     * The path is evaluated as per {@link Project#file(Object)}.
     *
     * @param path The path evaluated as per {@link Project#file(Object)}.
     * @since 7.0
     */
    ReadableResource gzip(Object path);

    /**
     * Creates resource that points to a bzip2 compressed file at the given path.
     * The path is evaluated as per {@link Project#file(Object)}.
     *

public interface BuildListener {

    /**
     * Called when the build settings are about to be loaded and evaluated.
     *
     * @param settings The settings. Never null.
     * @since 6.0
     */
    default void beforeSettings(Settings settings) {}

    /**
     * <p>Called when the build settings have been loaded and evaluated. The settings object is fully configured and is
     * ready to use to load the build projects.</p>
     *

        executer.usingInitScript(file('init.gradle'))

        when:
        succeeds 'hello'

        then:
        output.contains("Project buildSrc evaluated")
        output.contains("Project hello evaluated")
    }

    def 'init scripts passed in the Gradle user home are applied to buildSrc'() {
        given:
        settingsFile << "rootProject.name = 'hello'"
        createProject()

    /**
     * Returns the set of source paths for this collection. The paths are evaluated as per {@link org.gradle.api.Project#files(Object...)}.
     *
     * @return The set of source paths. Returns an empty set if none.
     */
    Set<Object> getFrom();

    /**
     * Sets the source paths for this collection. The given paths are evaluated as per {@link org.gradle.api.Project#files(Object...)}.
     *
     * @param paths The paths.

        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"

                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

 *
 * @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>,