) : ProjectEvaluator {
    override fun evaluate(project: ProjectInternal, state: ProjectStateInternal) {
        controller.runCollectingFingerprintForProject(project.identityPath) {
            delegate.evaluate(project, state)
        }
    }

 * limitations under the License.
 */

package org.gradle.internal.cc.impl.cacheentry

import org.gradle.internal.hash.HashCode
import org.gradle.util.Path


internal
data class ModelKey(
    val identityPath: Path?,
    val modelName: String,
    val parameterHash: HashCode?

    override fun computeIfAbsent(project: ProjectState, factory: Function<ProjectState, LocalComponentGraphResolveState>): LocalComponentGraphResolveState {
        return cache.loadOrCreateProjectMetadata(project.identityPath) {
            factory.apply(project)
        }
    }

        }
    }

    private
    fun reportProjectIsolationProblemOnApiUsage() {
        val problem = problemFactory.problem {
            text("Project ")
            reference(referrer.identityPath.toString())
            text(" cannot access task dependencies directly")
        }
            .exception()
            .build()
        problems.onProblem(problem)
    }

            sideEffect.runSideEffect()
        }
    }

    override fun <T> loadOrCreateIntermediateModel(identityPath: Path?, modelName: String, parameter: ToolingModelParameterCarrier?, creator: () -> T?): T? {
        return intermediateModels.loadOrCreateIntermediateModel(identityPath, modelName, parameter, creator)
    }

        override fun getTarget() = delegate.target

        override fun getModel(modelName: String, parameter: ToolingModelParameterCarrier?): Any? {
            return cache.loadOrCreateIntermediateModel(target?.identityPath, modelName, parameter) {
                delegate.getModel(modelName, parameter)
            }
        }
    }

                            def builds = []
                            registry.visitBuilds { b ->
                                builds.add(b.identityPath.path)
                                if (b.projectsLoaded) {
                                    projects.addAll(b.projects.allProjects.collect { p -> p.identityPath.path })
                                }
                            }
                            println "projects = " + projects

        addBuilderRegisteringPluginImplementation(childBuildName, "MyModelBuilder", """
            def model = project.extensions.create("myExtension", MyExtension)
            model.message = "It works from project \${project.identityPath}"
        """)
    }

    void withParameterizedSomeToolingModelBuilderPluginInChildBuild(String childBuildName, String builderContent = "") {
        addPluginBuildScript(childBuildName)

    withIsolate(IsolateOwners.OwnerTask(task), codec) {
        withPropertyTrace(PropertyTrace.Task(taskType, task.identityPath.path)) {
            if (task.isCompatibleWithConfigurationCache) {
                action()
            } else {
                forIncompatibleType(task.identityPath.path, action)
            }
        }
    }
}


private
sealed class RegisteredProperty {

        }

        override fun getPluginManager(): PluginManagerInternal {
            onAccess("pluginManager")
            return delegate.pluginManager
        }

        override fun identityPath(name: String): Path {
            shouldNotBeUsed()
        }

        override fun projectPath(name: String): Path {
            shouldNotBeUsed()
        }