configurer.configure(project.getMutableModel());
            if (taskNameResolver.tryFindUnqualifiedTaskCheaply(taskName, project.getMutableModel())) {
                // An exact match in the target project - can just filter tasks by path to avoid configuring subprojects at this point
                return new TaskPathSpec(project.getMutableModel(), taskName);
            }
        }

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

        renderReportUrl(file);
    }

    private File getBuildDir() {
        return buildStateRegistry
            .getRootBuild()
            .getProjects()
            .getRootProject()
            .getMutableModel()
            .getServices()
            .get(ProjectLayout.class)
            .getBuildDirectory()
            .getAsFile()
            .get();
    }

    private void renderReportUrl(File reportFile) {

    }

    @Override
    public void ensureProjectsConfigured() {
        getBuildController().configureProjects();
    }

    @Override
    public GradleInternal getMutableModel() {
        return getBuildController().getGradle();
    }

    @Override
    public BuildWorkGraphController getWorkGraph() {
        return workGraphController.get();
    }

    @Override

        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

            ProjectState targetState = projectStateRegistry.stateFor(projectResult.projectIdentity);
            ConfigurationInternal targetConfig = (ConfigurationInternal) targetState.getMutableModel().getConfigurations().findByName(projectResult.targetConfiguration);
            if (targetConfig != null) {
                // Can be null when dependency metadata for target project has been loaded from cache

        @Override
        public Project getOwningProject() {
            if (artifact.fileSource.getResourceToLock() instanceof ProjectState) {
                return ((ProjectState) artifact.fileSource.getResourceToLock()).getMutableModel();
            } else {
                return null;
            }
        }

        @Override
        public void visitDependencies(TaskDependencyResolveContext context) {

        if (componentIdentifier instanceof ProjectComponentIdentifier) {
            return projectStateRegistry.stateFor((ProjectComponentIdentifier) componentIdentifier).getMutableModel();
        } else {
            return null;
        }
    }

    private boolean isCachingDisabledByProperty(Transform transform) {

            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);
                }

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

    @Provides