private final List<NodeInitializerExtractionStrategy> additionalStrategies;
    private final ModelSchemaStore schemaStore;

    public DefaultNodeInitializerRegistry(ModelSchemaStore schemaStore, StructBindingsStore structBindingsStore) {
        this.schemaStore = schemaStore;
        this.allStrategies = Lists.newArrayList(
            new ModelSetNodeInitializerExtractionStrategy(),

    ModelRegistry registry = createModelRegistry()
    ModelSchemaStore schemaStore = SCHEMA_STORE
    ManagedProxyFactory proxyFactory = MANAGED_PROXY_FACTORY
    ModelRuleExtractor modelRuleExtractor = MODEL_RULE_EXTRACTOR
    StructBindingsStore structBindingsStore = STRUCT_BINDINGS_STORE
    NodeInitializerRegistry nodeInitializerRegistry = createNodeInitializerRegistry(schemaStore, structBindingsStore)

    def setup() {

                        ModelSchemaStore schemaStore = getInstance(modelViews, 0, ModelSchemaStore.class);
                        NodeInitializerRegistry nodeInitializerRegistry = getInstance(modelViews, 1, NodeInitializerRegistry.class);

                        addPropertyLinks(modelNode, schemaStore, nodeInitializerRegistry);
                        initializePrivateData(modelNode);

                                            ModelSchemaStore schemaStore,
                                            Iterable<? extends ModelType<?>> scalarTypes,
                                            Iterable<? extends ModelType<?>> constructibleTypes) {
        super(toMessage(context, schemaStore, scalarTypes, constructibleTypes));
    }

    private static final ModelType<NodeInitializerRegistry> NODE_INITIALIZER_REGISTRY = ModelType.of(NodeInitializerRegistry.class);

    private final ModelSchemaStore schemaStore;

    public ManagedModelCreationRuleExtractor(ModelSchemaStore schemaStore) {
        this.schemaStore = schemaStore;
    }

    @Override
    public String getDescription() {
        return String.format("%s and taking a managed model element", super.getDescription());

    abstract static class ManagedThing {}

    def "type doesn't need to implement named"() {
        when:
        schemaStore.getSchema(ModelTypes.modelMap(ManagedThing))

        then:
        noExceptionThrown()
    }

    def "must have type param"() {
        when:
        schemaStore.getSchema(ModelType.of(ModelMap))

        then:
        def e = thrown InvalidManagedModelElementTypeException

public abstract class AbstractBinaryRenderer<T extends BinarySpec> extends ReportRenderer<BinarySpec, TextReportBuilder> {
    private final ModelSchemaStore schemaStore;

    protected AbstractBinaryRenderer(ModelSchemaStore schemaStore) {
        this.schemaStore = schemaStore;
    }

    @Override
    public void render(BinarySpec binary, TextReportBuilder builder) {

import org.gradle.nativeplatform.NativeBinarySpec;

public class NativeBinaryRenderer extends AbstractNativeBinaryRenderer<NativeBinarySpec> {
    public NativeBinaryRenderer(ModelSchemaStore schemaStore) {
        super(schemaStore);
    }

    @Override
    public Class<NativeBinarySpec> getTargetType() {
        return NativeBinarySpec.class;
    }

    private static class GlobalScopeServices implements ServiceRegistrationProvider {
        @Provides
        MethodModelRuleExtractor createComponentModelPluginInspector(ModelSchemaStore schemaStore) {
            return new ComponentTypeModelRuleExtractor(schemaStore);
        }

        @Provides
        MethodModelRuleExtractor createComponentBinariesPluginInspector() {
            return new ComponentBinariesModelRuleExtractor();
        }

import javax.inject.Inject;

public class NativeTestSuiteBinaryRenderer extends AbstractNativeBinaryRenderer<NativeTestSuiteBinarySpec> {
    @Inject
    public NativeTestSuiteBinaryRenderer(ModelSchemaStore schemaStore) {
        super(schemaStore);
    }

    @Override
    public Class<NativeTestSuiteBinarySpec> getTargetType() {
        return NativeTestSuiteBinarySpec.class;
    }

    @Override