// Use the result of previous rules as the input for dependency substitution
        ComponentSelector requested = dependencySubstitution.getTarget();
        if (requested instanceof ModuleComponentSelector) {
            ModuleComponentSelector selector = (ModuleComponentSelector) requested;
            ProjectComponentIdentifier replacement = getReplacementFor(selector);

            }
            m = unwrap(replacements.get(m));
        }
    }

    private static ModuleIdentifier unwrap(Replacement replacement) {
        return replacement == null ? null : replacement.getTarget();
    }

    private static NotationParser<Object, ModuleIdentifier> parser(ImmutableModuleIdentifierFactory moduleIdentifierFactory) {
        return NotationParserBuilder

        }

        String namespace = toNamespace(settings.getProjectName());

        return templateOperationFactory.newTemplateOperation()
            .withTemplate(template)
            .withTarget(settings.getTarget().file(settings.getSubprojects().get(0) + "/src/" + sourceSetName + "/" + sourceDir + "/" + targetFileName).getAsFile())
            .withBinding("projectName", settings.getProjectName())

        for (IncludedBuildInternal reference : gradle.includedBuilds()) {
            BuildState target = reference.getTarget();
            if (target instanceof IncludedBuildState) {
                IncludedBuildState includedBuildState = (IncludedBuildState) target;

                            writer.print("\", type: .static");
                        }
                    }
                    writer.print(", targets: [\"");
                    writer.print(product.getTarget().getName());
                    writer.println("\"]),");
                }
                writer.println("    ],");
                if (!srcPackage.getDependencies().isEmpty()) {

        registerModifiedProperty("sortOrder");
        this.sortOrder = value;
    }

    public String getTarget() {
        checkSpecifiedProperty("target");
        return convertEmptyToNull(target);
    }

    public void setTarget(String value) {
        registerModifiedProperty("target");
        this.target = value;
    }

    public String getUpdatedBy() {

            p.getPluginManager().apply(IdeaPlugin.class);
        }
        for (IncludedBuildInternal reference : root.getGradle().includedBuilds()) {
            BuildState target = reference.getTarget();
            if (target instanceof IncludedBuildState) {
                target.ensureProjectsConfigured();
                GradleInternal build = target.getMutableModel();

                @InputFile
                @PathSensitive(PathSensitivity.NONE)
                abstract RegularFileProperty getSource()

                @OutputFile
                abstract RegularFileProperty getTarget()

                @TaskAction
                def execute() {
                    target.get().asFile.text = source.get().asFile.text
                }
            }

        super(modelRegistry, registration);
        this.parent = parent;
    }

    @Override
    public void setTarget(ModelNode target) {
        // Once the node has been discovered, changing the target is not allowed, as it changes the promise of the node as well
        if (getState() != State.Registered) {

        antTarget.addTask(testTask);
        task.setTarget(antTarget);
        task.setBaseDir(baseDir);
        task.executeAntTarget();
        assertTrue(testTask.executed);
    }

    @Test
    public void delegatesDescriptionToTarget() {
        antTarget.setDescription("description");

        task.setTarget(antTarget);
        assertThat(task.getDescription(), equalTo("description"));