}

    protected void invoke(ModelRuleInvoker<?> ruleInvoker, List<ModelView<?>> inputs, ModelMap<?> modelMap, T baseTypeParameter, Object... ignoredInputs) {
        List<Object> ignoredInputsList = Arrays.asList(ignoredInputs);
        Object[] args = new Object[inputs.size() + 2 - ignoredInputs.length];
        args[0] = modelMap;
        args[baseTypeParameterIndex] = baseTypeParameter;

        for (ModelView<?> view : inputs) {

    }

    public <T> T realizeModelElement(String path, ModelType<T> type) {
        project.modelRegistry.realize(path, type)
    }

    ModelMap<BinarySpec> getBinaries() {
        realizeModelElement("binaries", modelMap(BinarySpec))
    }

    NativeToolChainRegistry getToolChains() {
        realizeModelElement("toolChains", NativeToolChainRegistry)
    }

        assert mapNode != null;
        return mapNode;
    }

    public static <T> ModelMap<T> toView(MutableModelNode mapNode, ModelType<T> elementModelType) {
        mapNode.ensureUsable();
        return mapNode.asMutable(
                ModelTypes.modelMap(elementModelType),
                RuleContext.get()
        ).getInstance();
    }

        where:
        projectionType              | fullQualified
        "ModelMap<ComponentSpec>"   | "org.gradle.model.ModelMap<org.gradle.platform.base.ComponentSpec>"
        "ModelMap<CustomComponent>" | "org.gradle.model.ModelMap<CustomComponent>"
        "ComponentSpecContainer"    | "org.gradle.platform.base.ComponentSpecContainer"
    }

        }

        @BinaryTasks
        public void executableTasks(ModelMap<Task> tasks, final NativeExecutableBinarySpecInternal executableBinary) {
            NativeComponents.createExecutableTask(executableBinary, executableBinary.getExecutable().getFile());
        }

        @Defaults
        public void createBuildDependentComponentsTasks(ModelMap<Task> tasks, ComponentSpecContainer components, BinaryContainer binaries) {

        if (componentSpecs != null) {
            components.addAll(componentSpecs.values());
        }

        ModelMap<ComponentSpec> testSuites = modelElement("testSuites", modelMap(ComponentSpec.class));
        if (testSuites != null) {
            components.addAll(testSuites.values());
        }

        renderer.renderComponents(components);

  @Mutate void setFirstName(Person p) {
    p.firstName = "John"
  }
// end::plugin-mutate-rule[]

// tag::task-create-rule[]
  //Create a rule that modifies a ModelMap<Task> and takes as input a Person
  @Mutate void createHelloTask(ModelMap<Task> tasks, Person p) {
    tasks.create("hello") {
      doLast {
        println "Hello $p.firstName $p.lastName!"
      }
    }
  }
// end::task-create-rule[]
}

                void configurePlatform(Platform platform) {
                    platform.operatingSystem.name = "${platform.operatingSystem.name} 10"
                }

                @Mutate
                void addTask(ModelMap<Task> tasks, @Path("platform.operatingSystem") OperatingSystem os) {
                    tasks.create("fromPlugin") {
                        doLast {
                            println "plugin input: $os"

        e.cause.message == """Type $ModelMap.name<?> is not a valid model element type:
- type parameter of org.gradle.model.ModelMap cannot be a wildcard.

The type was analyzed due to the following dependencies:
${fullyQualifiedNameOf(managedType)}
  \\--- property 'managedWithNestedInvalidManagedType' (${fullyQualifiedNameOf(nestedManagedType)})
    \\--- property 'invalidManaged' ($ModelMap.name<?>)"""

        where:

    ModelPath path = ModelPath.path("map")

    ModelType<ModelMap<T>> getModelMapType() {
        ModelTypes.modelMap(itemType)
    }

    void mutate(@DelegatesTo(ModelMap) Closure<?> action) {
        registry.mutate(ModelReference.of(path, modelMapType), ClosureBackedAction.of(action))
    }

    void mutateWithoutDelegation(Action<ModelMap<T>> action) {
        registry.mutate(ModelReference.of(path, modelMapType), action)