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

    /**

            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

        // Make sure the project tree has been loaded and can be queried (but not necessarily configured)
        targetBuild.ensureProjectsLoaded();

        GradleInternal gradle = targetBuild.getMutableModel();
        addProjects(targetBuild, model);
        addIncludedBuilds(gradle, model, all);

        if (gradle.getParent() == null) {
            List<DefaultGradleBuild> allBuilds = new ArrayList<>();

        @Override
        public boolean usesMutableProjectState() {
            return true;
        }

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

        @Override
        public File calculateValue(NodeExecutionContext context) {
            return projectState.fromMutableState(p -> projectArtifact.getFile());
        }
    }

        @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) {

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