}

    private static NodeInitializer getNodeInitializer(ModelRuleDescriptor descriptor, ModelSchema<?> modelSchema, NodeInitializerRegistry nodeInitializerRegistry) {
        try {
            return nodeInitializerRegistry.getNodeInitializer(forType(modelSchema.getType()));
        } catch (ModelTypeInitializationException e) {

 */

package org.gradle.model.internal.core;

import org.gradle.model.internal.manage.schema.extract.NodeInitializerExtractionStrategy;

public interface NodeInitializerRegistry {
    NodeInitializer getNodeInitializer(NodeInitializerContext<?> nodeInitializerContext);

    void ensureHasInitializer(NodeInitializerContext<?> nodeInitializer);

    void registerStrategy(NodeInitializerExtractionStrategy strategy);

                }
            }
        }
        return new ModelTypeInitializationException(context, schemaStore, ScalarTypes.TYPES, constructibleTypes.build());
    }

    @Override
    public NodeInitializer getNodeInitializer(NodeInitializerContext<?> nodeInitializerContext) {
        try {
            return cache.get(nodeInitializerContext);
        } catch (ExecutionException e) {

        if (!instanceFactory.getBaseInterface().isAssignableFrom(schema.getType())) {
            return null;
        }
        NodeInitializer nodeInitializer = getNodeInitializer(Cast.<ModelSchema<? extends T>>uncheckedCast(schema));
        if (nodeInitializer == null) {

    }

    @Override
    public <S extends T> NodeInitializer initializer(ModelType<S> type, Spec<ModelType<?>> constraints) {
        return nodeInitializerRegistry.getNodeInitializer(forType(type));
    }

    Class<SpecialNamedThingInterface> specialItemClass = SpecialNamedThingInterface.class

    def setup() {
        registry.register(ModelRegistrations.of(path, nodeInitializerRegistry.getNodeInitializer(forType(modelMapType))).descriptor("creator").build())
    }

    def "cannot read child in mutative method"() {
        when:
        mutate {
            create('foo')
        }
        mutate {

    def setup() {
        registry.register(
            ModelRegistrations.of(collectionPath, nodeInitializerRegistry.getNodeInitializer(forType(collectionType)))
                .descriptor("define collection")
                .build()
        )
    }

    void mutate(@DelegatesTo(ModelSet) Closure<?> action) {

        try {
            NodeInitializerRegistry nodeInitializerRegistry = modelRegistry.realize(DEFAULT_REFERENCE.getPath(), DEFAULT_REFERENCE.getType());
            NodeInitializer nodeInitializer = nodeInitializerRegistry.getNodeInitializer(forType(modelType));
            modelRegistry.register(ModelRegistrations.of(modelPath, nodeInitializer).descriptor(descriptor).build());
        } catch (ModelTypeInitializationException e) {

        ModelType<T> modelType = ModelType.of(type);
        NodeInitializer nodeInitializer = nodeInitializerRegistry.getNodeInitializer(forType(modelType));
        modelRegistry.register(
            ModelRegistrations.of(modelPath, nodeInitializer)
                .descriptor(descriptor)

        def collectionSchema = schemaStore.getSchema(collectionType)
        assert collectionSchema instanceof ManagedImplSchema
        def nodeInitializer = nodeInitializerRegistry.getNodeInitializer(forType(collectionSchema.getType()))
        reference = ModelReference.of(collectionPath, collectionType)
        registry.register(
            ModelRegistrations.of(collectionPath, nodeInitializer)