]).asImmutable().withDerivationStrategy(JavaEcosystemVariantDerivationStrategy.instance).asMutable()

        when:
        mavenMetadata.variantMetadataRules.addDependencyAction(instantiator, notationParser, constraintNotationParser, variantAction("default", {
            assert it.size() == 1

            throw new IllegalStateException("Cannot get view for node " + node.getPath() + " in state " + node.getState());
        }
        ModelType<T> type = getSubject().getType();
        ModelView<? extends T> view = node.asMutable(type, getDescriptor());
        try {
            execute(node, view.getInstance(), inputs);
        } finally {
            view.close();
        }
    }

        return descriptor;
    }

    @Override
    public void execute(ModelRuleInvoker<?> invoker, MutableModelNode modelNode, List<ModelView<?>> inputs) {
        ModelView<? extends T> subjectView = modelNode.asMutable(getSubject().getType(), descriptor);
        try {
            execute(invoker, subjectView.getInstance(), inputs);
        } finally {
            subjectView.close();
        }
    }

     * Note that this method can be expensive. Often it is more efficient to use a more specialised mutation method such as {@link #withSources(ModuleSources)} rather than this method.
     */
    MutableModuleComponentResolveMetadata asMutable();

    /**
     * Creates a copy of this meta-data with the given sources.
     */
    ModuleComponentResolveMetadata withSources(ModuleSources sources);

    /**

    }

    @Override
    public <T> ModelView<? extends T> asMutable(final ModelType<T> type, ModelRuleDescriptor ruleDescriptor) {
        if (target == null) {
            return InstanceModelView.of(getPath(), type, null);
        } else {
            return new ModelViewWrapper<T>(getPath(), target.asMutable(type, ruleDescriptor));
        }
    }

    @Override

            return Cast.uncheckedCast(toView(node, ruleDescriptor, false));
        } else {
            return null;
        }
    }

    @Nullable
    @Override
    public <T> ModelView<? extends T> asMutable(ModelType<T> type, MutableModelNode node, ModelRuleDescriptor ruleDescriptor) {
        if (canBeViewedAs(type)) {
            return Cast.uncheckedCast(toView(node, ruleDescriptor, true));
        } else {

    }

    @Override
    public ModuleMetadataCache.CachedMetadata dehydrate() {
        if (metadata == null) {
            return this;
        }
        MutableModuleComponentResolveMetadata copy = this.metadata.asMutable();

        ModuleComponentResolveMetadata asImmutable = copy.asImmutable();
        return new DefaultCachedMetadata(ageMillis, asImmutable);
    }

                                                  String name, Closure<I> createUnmanagedInstance) {
        def node = createNode(publicType, internalView, implType, name, createUnmanagedInstance)
        return node.asMutable(ModelType.of(publicType), new SimpleModelRuleDescriptor("<get $name>")).instance
    }

    static <B, T extends B, I extends B> MutableModelNode createNode(Class<T> publicType, Class<? extends B> internalView, Class<I> implType,

    }

    private MutableModuleComponentResolveMetadata createMutableMetadataIfNeeded() {
        if (mutableMetadata == null) {
            mutableMetadata = metadata.asMutable();
        }
        return mutableMetadata;
    }

    }

    void apply(MethodRuleDefinition<?, ?> definition) {
        def rule = extract(definition)
        def registryNode = Stub(MutableModelNode) {
            isAtLeast(_) >> true
            asMutable(_, _) >> { ModelType type, ModelRuleDescriptor ruleDescriptor ->
                return Stub(ModelView) {
                    getInstance() >> { Stub(type.concreteClass) }
                }
            }