controller.createMutableModel(descriptor, owner, this, selfClassLoaderScope, baseClassLoaderScope, projectFactory);
        }

        @Override
        public ProjectInternal getMutableModel() {
            return controller.getMutableModel();
        }

        @Override
        public void ensureConfigured() {
            // Need to configure intermediate parent projects for configure-on-demand

        projectState.createMutableModel(parentProject.getClassLoaderScope().createChild("project-" + name, null), parentProject.getBaseClassLoaderScope());
        ProjectInternal project = projectState.getMutableModel();

        // Lock the project, these won't ever be released as ProjectBuilder has no lifecycle
        ResourceLockCoordinationService coordinationService = project.getServices().get(ResourceLockCoordinationService.class);

        if (!path.isAbsolute() && path.segmentCount() == 1) {
            return new ProjectResolutionResult(targetBuild, targetBuild.getMutableModel().getDefaultProject().getOwner(), true, path.getName());
        }

        // <path>:name -> resolve <path> to a project + select task with matching name in that project

    private State buildState() {
        State state = new State();

        List<ProjectInternal> orderedProjects = Ordering.usingToString().sortedCopy(projectRegistry.getAllProjects().stream().map(ProjectState::getMutableModel).collect(Collectors.toList()));
        for (ProjectInternal project : orderedProjects) {
            if (project.getPlugins().hasPlugin(ComponentModelBasePlugin.class)) {

            BuildState target = reference.getTarget();
            if (target instanceof IncludedBuildState) {
                target.ensureProjectsConfigured();
                GradleInternal build = target.getMutableModel();
                if (!alreadyProcessed.contains(build)) {
                    alreadyProcessed.add(build);
                    applyEclipsePlugin(build.getRootProject(), alreadyProcessed);
                }

            BuildState target = reference.getTarget();
            if (target instanceof IncludedBuildState) {
                GradleInternal build = target.getMutableModel();
                if (!alreadyProcessed.contains(build)) {
                    alreadyProcessed.add(build);
                    applyIdeaPluginToBuildTree(build.getRootProject(), alreadyProcessed);
                }

        return new BuildOperationWrappingBuilder(
            new LockSingleProjectBuilder(
                locateForClientOperation(modelName, target.getMutableModel(), parameter), target),
            modelName, target.getOwner(), target, target.getDisplayName(), buildOperationRunner);
    }

    @Nullable
    @Override

        if (parent == null) {
            parentRegistry = rootRegistry.createChild(project.getBaseClassLoaderScope());
        } else {
            parentRegistry = parent.getMutableModel().getServices().get(PluginRegistry.class);
        }
        return parentRegistry.createChild(project.getClassLoaderScope());
    }

    @Provides

        private ProjectInternal findProjectOf(BuildState build, Path projectPath) {
            ProjectState project = build.getProjects().findProject(projectPath);
            return project != null
                ? project.getMutableModel()
                : null;
        }

        @Nullable
        private BuildState findBuild(Path buildPath) {
            return getBuildStateRegistry().findBuild(new DefaultBuildIdentifier(buildPath));

            return description + " (" + context + ")";
        }
    }

    @Override
    public GradleInternal getParent() {
        return parent == null ? null : parent.getMutableModel();
    }

    @Override
    public GradleInternal getRoot() {
        GradleInternal parent = getParent();
        if (parent == null) {
            return this;
        } else {