}

        return new DefaultComponentSpecIdentifier(projectIdentifier.getPath(), name);
    }

    @Nullable
    private MutableModelNode findOwner(MutableModelNode modelNode) {
        MutableModelNode grandparentNode = modelNode.getParent().getParent();
        if (grandparentNode != null && grandparentNode.canBeViewedAs(ModelType.of(ComponentSpecInternal.class))) {
            return grandparentNode;
        }

        return new NoInputsModelAction<T>(reference, descriptor, configAction);
    }

    @Override
    public void execute(MutableModelNode modelNode, T view, List<ModelView<?>> inputs) {
        configAction.execute(view);
    }

            @Override
            public void execute(MutableModelNode modelNode, T t, List<ModelView<?>> inputs) {
                action.execute(modelNode, t, inputs);
            }
        });
    }

 */

package org.gradle.model.internal.core;

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

public interface ModelViewFactory<M> {
    ModelView<M> toView(MutableModelNode modelNode, ModelRuleDescriptor ruleDescriptor, boolean mutable);

        return new Predicate<MutableModelNode>() {
            @Override
            public boolean apply(MutableModelNode node) {
                node.ensureAtLeast(ModelNode.State.Discovered);
                return node.canBeViewedAs(type) && predicate.apply(node);
            }
        };
    }

import org.gradle.model.internal.core.ModelPredicate;

abstract class ModelListener extends ModelPredicate {
    /**
     * Invoked once for each node when the node reaches the {@link org.gradle.model.internal.core.ModelNode.State#Discovered} state
     * if the node matches the criteria specified by this listener.
     */
    public abstract void onDiscovered(ModelNodeInternal node);

    }

    @Override
    public <T> ModelView<? extends T> asImmutable(ModelType<T> type, MutableModelNode modelNode, @Nullable ModelRuleDescriptor ruleDescriptor) {
        return doAs(type, modelNode, ruleDescriptor, false);
    }

    @Override
    public <T> ModelView<? extends T> asMutable(ModelType<T> targetType, MutableModelNode node, ModelRuleDescriptor ruleDescriptor) {

                initializer.execute(t, ModelViews.assertType(modelViews.get(0), input.getType()).getInstance());
            }
        });
    }

    @Override
    protected void execute(MutableModelNode modelNode, T view, List<ModelView<?>> inputs) {
        action.execute(view, inputs);
    }

        def barRegistration = ModelRegistrations.unmanagedInstance(barReference, factory).descriptor(descriptor).build()
        registry.register(barRegistration)
        def foo = registry.atStateOrLater(fooReference.path, ModelNode.State.Discovered)

        then:
        !foo.promise.canBeViewedAs(ModelType.of(String))
        foo.promise.canBeViewedAs(ModelType.of(List))

        registry.realize(fooReference.path, fooReference.type).is(fooList)

    interface ImplementationInfo {
        /**
         * Creates an instance of the delegate for the given node.
         */
        Object create(MutableModelNode modelNode);

        /**
         * The default implementation type that can be used as a delegate for any managed subtypes of the public type.
         */
        ModelType<?> getDelegateType();

        /**