renderReportUrl(file);
    }

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

    private void renderReportUrl(File reportFile) {

            context.add(resolveTask());
        }

        private Task resolveTask() {
            rootBuildState.ensureProjectsConfigured();
            return rootBuildState.getMutableModel().getRootProject().getTasks().getByPath(taskPath);
        }
    }

            ensureChildBuildConfigured();
            availableModules = new LinkedHashSet<>();
            for (ProjectState project : getProjects().getAllProjects()) {
                registerProject(availableModules, project.getMutableModel());
            }
        }
        return availableModules;
    }

    protected void ensureChildBuildConfigured() {
        ensureProjectsConfigured();
    }

        if (!seen.add(build)) {
            return;
        }
        boolean added = registering.add(build);
        try {
            for (IncludedBuildInternal reference : build.getMutableModel().includedBuilds()) {
                BuildState target = reference.getTarget();
                if (!registering.contains(target) && target instanceof IncludedBuildState) {

            // Force configuration of the target project to ensure all builders have been registered
            target.ensureConfigured();
            ToolingModelBuilderLookup lookup = target.getMutableModel().getServices().get(ToolingModelBuilderLookup.class);
            return lookup.locateForClientOperation(modelName, parameter, target);
        }
    }

                // try to get the name from EclipseProject.name
                state.getOwner().ensureProjectsConfigured();
                EclipseModel model = state.getMutableModel().getExtensions().findByType(EclipseModel.class);
                if (model != null && model.getProject().getName() != null) {

    }

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

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

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

    @Override

    public <T> T withState(Transformer<T, ? super GradleInternal> action) {
        // This should apply some locking, but most access to the build state does not happen via this method yet
        return action.transform(getMutableModel());
    }

    @Override
    public ExecutionResult<Void> finishBuild() {
        return getBuildController().finishBuild(null);
    }

     */
    File getBuildRootDir();

    /**
     * Returns the current state of the mutable model of this build. Try to avoid using the model directly.
     */
    GradleInternal getMutableModel();

    /**
     * Returns the work graph for this build.
     */
    BuildWorkGraphController getWorkGraph();

    /**

        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