return ConfigurationTargetIdentifier.of(settings);
    }

    @Provides
    protected GradleInternal createGradleInternal() {
        return settings.getGradle();
    }

    @Provides

            return false;
        }

        ProjectInternal project = (ProjectInternal) domainObjectContext;

        boolean hasSettingsRepos;
        try {
            hasSettingsRepos = !project.getGradle().getSettings().getDependencyResolutionManagement().getRepositories().isEmpty();
        } catch (Throwable e) {
            // To catch `The settings are not yet available for` error
            return false;
        }

        List<TaskDependency> buildDependencies = populate(project.getRootProject());
        if (!buildDependencies.isEmpty()) {
            Gradle rootGradle = getRootGradle(project.getGradle());
            Project rootProject = rootGradle.getRootProject();
            StartParameter startParameter = rootGradle.getStartParameter();
            List<String> taskPaths = new ArrayList<>(startParameter.getTaskNames());

    private final BuildListener buildListener = new InternalBuildAdapter() {
        @Override
        public void beforeSettings(Settings settings) {
            if (settings.getGradle().getParent() == null) {
                settings.getGradle().projectsLoaded((InternalAction<Gradle>) project -> {
                    State s = state;
                    if (s != null && s.notificationListener == null) {

    def clientSubscriptions = Mock(BuildEventSubscriptions)
    def payloadSerializer = Mock(PayloadSerializer)
    def gradle = Stub(GradleInternal)
    def buildController = Mock(BuildTreeLifecycleController) {
        getGradle() >> this.gradle
    }
    def modelController = Stub(BuildTreeModelController)
    def clientProvidedBuildAction = new ClientProvidedBuildAction(startParameter, action, false /* isRunTasks */, clientSubscriptions)

        when:
        def project = Mock(ProjectInternal) {
            projectPath(_) >> Path.path(":foo:bar")
            identityPath(_) >> Path.path("build:foo:bar")
            getGradle() >> Mock(GradleInternal) {
                getIdentityPath() >> Path.path(":build:foo:bar")
            }
        }

                @Override
                public void apply(Settings target) {
                    Extension restricted = target.getExtensions().create("restricted", Extension.class);
                    target.getGradle().settingsEvaluated(settings -> {
                        System.out.println("id = " + restricted.getId().get());
                    });
                }
            }
        """

    }

    @Override
    public void beforeBuild(Consumer<? super GradleInternal> action) {
        state.inState(State.NotStarted, () -> action.accept(buildLifecycleController.getGradle()));
    }

    @Override
    public void scheduleAndRunTasks() {
        scheduleAndRunTasks(null);
    }

    @Override
    public void scheduleAndRunTasks(@Nullable EntryTaskSelector selector) {

    override fun removeListener(listener: Any) =
        delegate.removeListener(listener)

    override fun useLogger(logger: Any) =
        delegate.useLogger(logger)

    override fun getGradle(): Gradle =
        delegate.gradle

    override fun getSharedServices() = delegate.sharedServices

    override fun getIncludedBuilds(): MutableCollection<IncludedBuild> =
        delegate.includedBuilds

                        final Dsl dsl = target.getExtensions().create("dsl", Dsl.class);
                        target.getGradle().getLifecycle().beforeProject(project -> {
                            project.getTasks().register("test", TestTask.class, task -> {
                                task.getTaskParameter().set(dsl.getParameter());