Path identityPath = Path.path(decoder.readString());
                return new DefaultProjectComponentIdentifier(buildIdentifier, identityPath, Path.ROOT, identityPath.getName());
            }
            case OTHER_BUILD_PROJECT: {
                BuildIdentifier buildIdentifier = buildIdentifierSerializer.read(decoder);
                Path identityPath = Path.path(decoder.readString());

        Path identityPath = assignPath(owner, buildDefinition.getName(), buildDefinition.getBuildRootDir());
        BuildIdentifier buildIdentifier = idFor(identityPath);
        StandAloneNestedBuild build = buildStateFactory.createNestedBuild(buildIdentifier, identityPath, buildDefinition, owner);
        buildSrcBuildsByOwner.put(owner, build);

     *
     * @param identityPath The project for which the model should be created, or null for a build scoped model.
     */
    fun <T> loadOrCreateIntermediateModel(identityPath: Path?, modelName: String, parameter: ToolingModelParameterCarrier?, creator: () -> T?): T?

    /**

        }
        reportCrossProjectTaskAccess(otherProjects)
    }

    private
    val Project.isReferrerProject: Boolean
        get() = this is ProjectInternal && identityPath == referrerProject.identityPath

    private
    fun reportCrossProjectTaskAccess(coupledProjects: Iterable<ProjectInternal>, requestPath: String? = null) {
        reportCoupledProjects(coupledProjects)

        readString()

    private
    fun identifyBuild(state: CachedBuildState) {
        val identityPath = state.identityPath.toString()

        eventEmitter.emitNowForCurrent(BuildIdentifiedProgressDetails { identityPath })

        if (state is BuildWithProjects) {
            val projects = convertProjects(state.projects, state.rootProjectName)

        for (entry in entryDetails) {
            val identityPath = projectPathForKey(entry.key)
            if (identityPath == null || !checkedFingerprint.invalidProjects.contains(identityPath)) {
                // Can reuse the value
                previousValues[entry.key] = entry.value
            }
        }
    }

        Path identityPath = projectInternal.getIdentityPath();
        String displayName = "Configure project " + identityPath;

        String progressDisplayName = identityPath.toString();
        if (identityPath.equals(Path.ROOT)) {
            progressDisplayName = "root project";
        }

    }

    override fun onProjectReference(referrer: ProjectState, target: ProjectState) {
        if (referrer.identityPath == target.identityPath)
            return

        if (host.cacheIntermediateModels) {
            val dependency = ProjectSpecificFingerprint.CoupledProjects(referrer.identityPath, target.identityPath)
            if (projectDependencies.add(dependency)) {
                projectScopedWriter.write(dependency)

        String taskName
    ) {
        for (ProjectDependency projectDependency : projectDependencies) {
            Path identityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();
            ProjectState projectState = projectStateRegistry.stateFor(identityPath);
            projectState.ensureTasksDiscovered();

            Task nextTask = projectState.getMutableModel().getTasks().findByName(taskName);

        } else {
            PropertyTrace.Task(GeneratedSubclasses.unpackType(task), task.identityPath.path)
        }

    private
    fun problemsListenerFor(task: TaskInternal): ProblemsListener = when {
        task.isCompatibleWithConfigurationCache -> problems
        else -> problems.forIncompatibleTask(task.identityPath.path)
    }