return withCoordinateResolver(coordsType, identityPath,
            VariantCoordinateResolver::getComponentCoordinates
        );
    }

    @Nullable
    @Override
    public <T> T resolveVariant(Class<T> coordsType, Path identityPath, String variantName) {
        return withCoordinateResolver(coordsType, identityPath, resolver ->

    /**
     * Determines the coordinates of the given type for the root component of the
     * project identified by {@code identityPath}.
     *
     * @throws UnsupportedOperationException if the project cannot be resolved.
     */
    <T> T resolveComponent(Class<T> coordsType, Path identityPath);

    /**
     * Determines the coordinates of the given type that should be used to reference the

                return false;
            }

            Path identityPath = ((ProjectInternal) originProject).getIdentityPath();
            return doesConfigurationDependOnProject(configuration, identityPath);
        }

        private static boolean doesConfigurationDependOnProject(Configuration configuration, Path identityPath) {

        }
    }

    private static class ProjectDependencyKey {
        private final Path identityPath;
        private final ModuleDependencyDetails details;

        public ProjectDependencyKey(Path identityPath, ModuleDependencyDetails details) {
            this.identityPath = identityPath;
            this.details = details;
        }

        @Override
        public boolean equals(Object o) {

        this.buildDefinition = buildDefinition;
        this.buildIdentifier = buildIdentifier;
        this.identityPath = identityPath;
        this.owner = owner;
        this.userHomeDirServiceRegistry = userHomeDirServiceRegistry;
        this.crossBuildSessionState = crossBuildSessionState;
        this.buildCancellationToken = buildCancellationToken;
    }

    @Override

        def selector = new DefaultProjectComponentSelector(new DefaultBuildIdentifier(path(":build")), identityPath, projectPath, projectName, AttributeTestUtil.attributes(foo: 'x', bar: 'y'), capabilities())

        when:
        def result = serialize(selector, serializer)

        then:
        result.identityPath == selector.identityPath
        result.projectPath == selector.projectPath

        Path identityPath = ((ProjectDependencyInternal) dependency).getIdentityPath();
        ModuleVersionIdentifier coordinates = projectDependencyResolver.resolveComponent(ModuleVersionIdentifier.class, identityPath);
        ModuleVersionIdentifier resolved = maybeResolveVersion(coordinates.getGroup(), coordinates.getName(), identityPath);

        }

        override fun <T> resolveScriptsForProject(identityPath: Path, action: () -> T): T {
            return fingerprintWriter.runCollectingFingerprintForProject(identityPath, action)
        }

        override fun <T> runCollectingFingerprintForProject(identityPath: Path, action: () -> T): T {
            return fingerprintWriter.runCollectingFingerprintForProject(identityPath, action)
        }

    private final BuildIdentifier buildIdentifier;
    private final Path identityPath;
    private final BuildTreeLifecycleController buildTreeLifecycleController;

    public RootOfNestedBuildTree(
        BuildDefinition buildDefinition,
        BuildIdentifier buildIdentifier,
        Path identityPath,
        BuildState owner,
        BuildTreeState buildTree
    ) {

        nestedBuild1.identityPath == Path.path(":buildSrc")

        def nestedBuild2 = registry.getBuildSrcNestedBuild(parent)
        // Shows current behaviour, not necessarily desired behaviour
        nestedBuild2.buildIdentifier == buildIdentifier(":parent:buildSrc")
        nestedBuild2.identityPath == Path.path(":parent:buildSrc")
    }

    def build(String name) {