}

    public static <T> ModelReference<T> of(ModelPath path, ModelType<T> type) {
        return Cast.uncheckedCast(new ModelReference<T>(path, type, null, null, null));
    }

    public static <T> ModelReference<T> of(ModelPath path, ModelType<T> type, ModelNode.State state) {
        return Cast.uncheckedCast(new ModelReference<T>(path, type, null, state, null));
    }

    public static <T> ModelReference<T> of(ModelPath path, Class<T> type) {

public abstract class ModelRegistrations {

    public static <T> Builder serviceInstance(ModelReference<T> modelReference, T instance) {
        return bridgedInstance(modelReference, instance)
            .hidden(true);
    }

    public static <T> Builder bridgedInstance(ModelReference<T> modelReference, T instance) {
        return unmanagedInstance(modelReference, Factories.constant(instance), Actions.doNothing());
    }

            @Override
            public boolean apply(ModelReference<?> element) {
                return element.getType().equals(baseType);
            }
        });
    }

    private static ImmutableList<ModelReference<?>> calculateInputs(final ModelType<?> baseType, final List<ModelReference<?>> references, List<ModelReference<?>> modelReferences) {

        return new InputUsingModelAction<T>(modelReference, descriptor, inputs, initializer);
    }

    public static <T, I> InputUsingModelAction<T> single(ModelReference<T> modelReference, ModelRuleDescriptor descriptor, final ModelReference<I> input, final BiAction<? super T, ? super I> initializer) {

    }

    @Nullable
    @Override
    public ModelReference<S> getSubjectReference() {
        return Cast.uncheckedCast(references.isEmpty() ? null : references.get(0));
    }

    @Override
    public List<ModelReference<?>> getTailReferences() {
        return references.size() > 1 ? references.subList(1, references.size()) : Collections.<ModelReference<?>>emptyList();
    }

    @Override

        def pathAndType = ModelReference.of("path", String)
        def scopeAndType = ModelReference.of(String).inScope(ModelPath.path("scope"))

        Matchers.strictlyEquals(path, ModelReference.of("path"))
        Matchers.strictlyEquals(type, ModelReference.of(String))
        Matchers.strictlyEquals(pathAndType, ModelReference.of("path", String))
        Matchers.strictlyEquals(scopeAndType, type.inScope(ModelPath.path("scope")))

        private final ModelRuleDescriptor descriptor;
        private final ModelReference<?> subject;
        private final ModelType<T> type;
        private final List<ModelReference<?>> inputs;

        private UnmanagedElementCreationAction(ModelRuleDescriptor descriptor, ModelReference<?> subject, List<ModelReference<?>> inputs, ModelType<T> type) {
            this.subject = subject;
            this.inputs = inputs;

package org.gradle.model.internal.inspect;

import org.gradle.model.internal.core.ModelReference;
import org.gradle.model.internal.core.ModelView;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

import java.util.List;

class MethodBackedModelAction<T> extends AbstractMethodRuleAction<T> {
    private final List<ModelReference<?>> inputs;

    private DirectNodeNoInputsModelAction(ModelReference<T> subjectReference, ModelRuleDescriptor descriptor, BiAction<? super MutableModelNode, ? super T> action) {
        super(subjectReference, descriptor, Collections.<ModelReference<?>>emptyList());
        this.action = action;
    }

        private final ModelReference<?> targetReference;
        private final ModelRuleDescriptor descriptor;
        private final List<ModelReference<?>> inputs;
        private final ModelType<? extends RuleSource> ruleSourceType;
        private final ModelRuleExtractor ruleExtractor;