binder {
            descriptor("ruleWithUnboundSubjectReference")
            subjectReference(ModelReference.of(String).inScope(ModelPath.path("some.scope")))
            inputReference(String)
            inputReference(ModelReference.of(Boolean).inScope(ModelPath.path("other.scope")))
        }

        expect:
        reportForProcessedBinders == reportFor(

import org.gradle.internal.Actions;
import org.gradle.internal.MutableBoolean;
import org.gradle.model.internal.core.ModelActionRole;
import org.gradle.model.internal.core.ModelPath;
import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.core.ModelRegistrations;
import org.gradle.model.internal.core.NoInputsModelAction;
import org.gradle.model.internal.core.NodeInitializer;

        public ModelMapNodeInitializer(CollectionSchema<T, E> schema) {
            this.schema = schema;
        }

        @Override
        public Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor) {
            return ImmutableSetMultimap.<ModelActionRole, ModelAction>builder()
                .put(ModelActionRole.Discover, AddProjectionsAction.of(subject, descriptor,

import java.util.List;

public abstract class AbstractModelActionWithView<T> extends AbstractModelAction<T> {
    protected AbstractModelActionWithView(ModelReference<T> subject, ModelRuleDescriptor descriptor, List<? extends ModelReference<?>> inputs) {
        super(subject, descriptor, inputs);
    }

    @Override
    final public void execute(MutableModelNode node, List<ModelView<?>> inputs) {

        return assertType(untypedView, ModelType.of(type));
    }

    public static <T> ModelView<T> assertType(ModelView<?> untypedView, ModelReference<T> reference) {
        return assertType(untypedView, reference.getType());
    }

    public static <T> T getInstance(ModelView<?> untypedView, ModelReference<T> reference) {
        return assertType(untypedView, reference.getType()).getInstance();
    }

import org.gradle.internal.Cast;
import org.gradle.internal.Factory;
import org.gradle.model.internal.core.ModelActionRole;
import org.gradle.model.internal.core.ModelPath;
import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.core.ModelRegistration;
import org.gradle.model.internal.core.ModelRegistrations;
import org.gradle.model.internal.core.MutableModelNode;

package org.gradle.model.internal.report;

import com.google.common.collect.ImmutableList;
import javax.annotation.concurrent.ThreadSafe;
import org.gradle.model.internal.core.ModelPath;
import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;
import org.gradle.util.internal.CollectionUtils;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Comparator;

    def registry = new DefaultModelRegistry(null, null)

    def "action is called"() {
        when:
        def fooReference = ModelReference.of("foo", List)
        def barReference = ModelReference.of("bar", List)

        def descriptor = new SimpleModelRuleDescriptor("foo")

        def fooList = []

        void setValue(String value)
    }

    def collectionPath = ModelPath.path("collection")
    def collectionType = new ModelType<ModelSet<NamedThing>>() {}
    private ModelReference<ModelSet<NamedThing>> reference = ModelReference.of(collectionPath, new ModelType<ModelSet<NamedThing>>() {})

    def setup() {
        registry.register(

import org.gradle.internal.service.ServiceRegistry
import org.gradle.internal.typeconversion.TypeConverter
import org.gradle.model.internal.core.DefaultNodeInitializerRegistry
import org.gradle.model.internal.core.ModelReference
import org.gradle.model.internal.core.ModelRegistrations
import org.gradle.model.internal.core.NodeInitializerRegistry
import org.gradle.model.internal.inspect.ModelRuleExtractor