then:
        failure.assertHasCause("Exception thrown while executing model rule: MyPlugin#addTasks2(ModelMap<Task>, MyModel)")
        failure.assertHasCause("Cannot create 'tasks.a' using creation rule 'MyPlugin#addTasks2(ModelMap<Task>, MyModel) > create(a)' as the rule 'MyPlugin#addTasks1(ModelMap<Task>, MyModel) > create(a)' is already registered to create this model element.")
    }

        node_names.size() != node_maxs.size()) {
      return true;
    }
    for (int i = 0; i < node_names.size(); ++i) {
      quant_specs->input_ranges.push_back({node_mins[i], node_maxs[i]});
    }
    return false;
  }
  if (!node_mins.empty()) {
    llvm::dbgs() << "Ignored input_min_values.";
  }
  if (!node_maxs.empty()) {
    llvm::dbgs() << "Ignored input_max_values.";
  }

import groovy.lang.GroovyObject;
import org.gradle.model.ModelMap;
import org.gradle.model.ModelSet;

import java.util.ArrayDeque;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Queue;
import java.util.Set;

public abstract class ModelTypes {

    public static <I> ModelType<ModelMap<I>> modelMap(Class<I> type) {
        return modelMap(ModelType.of(type));
    }

        static void noBinaryParameter(ModelMap<Task> builder) {
        }

        @BinaryTasks
        static void multipleBinaryParameters(ModelMap<Task> builder, BinarySpec b1, BinarySpec b2) {
        }

        @BinaryTasks
        private <T> T multipleProblems(String p1, String p2) {
        }

        @BinaryTasks
        static void validTypeRule(ModelMap<Task> tasks, SomeBinarySpec binary) {

            if (!type.getRawClass().equals(ModelMap.class)) {
                extractionContext.add(String.format("subtyping %s is not supported.", ModelMap.class.getName()));
                return;
            }

            if (type.isHasWildcardTypeVariables()) {
                extractionContext.add(String.format("type parameter of %s cannot be a wildcard.", ModelMap.class.getName()));
                return;
            }

        failure.assertHasCause("Exception thrown while executing model rule: RulePlugin#tryToModifyCompositeSubjectOfAnotherRule(ModelMap<Task>, Person)")
        failure.assertHasCause("Attempt to modify a read only view of model element 'person.pet' of type 'Pet' given to rule RulePlugin#tryToModifyCompositeSubjectOfAnotherRule(ModelMap<Task>, Person)")
    }

    def "mutating managed inputs of a dsl rule is not allowed"() {
        when:

        fails()

        and:
        failure.assertHasCause("Exception thrown while executing model rule: RulePlugin#mutate(ModelMap<Task>, ModelMap<Person>)")
        failure.assertHasCause("Attempt to modify a read only view of model element 'people' of type 'ModelMap<Person>' given to rule RulePlugin#mutate(ModelMap<Task>, ModelMap<Person>)")
    }

    def "cannot mutate when used as subject of validate rule"() {
        when:

            }
            apply plugin: TestRules

            class ValidateTaskRules extends RuleSource {
                @Mutate
                void createValidateTask(ModelMap<Task> tasks, @Path("components.sampleLib.sources") ModelMap<LanguageSourceSet> sources) {
                    tasks.create("validate") {
                        assert sources.haxe != null
                        assert sources.haxe.publicData == "public"

                            tasks()
                            sources()
                        }
                        otherBinary(type: 'OtherSampleBinary', creator: 'MyComponentBinariesPlugin.Rules#createBinariesForSampleLibrary(ModelMap<SampleBinary>, SampleLibrary) > create(otherBinary)') {

@UnsupportedWithConfigurationCache(because = "software model")
class RuleSourceAppliedToModelMapElementIntegrationTest extends AbstractIntegrationSpec {

    def "rule source can be applied to ModelMap element"() {
        when:
        buildScript '''
            class MessageTask extends DefaultTask {
                @Internal
                String message = "default"

                @TaskAction