private final ModelType<?> publicType;

    private Collection<T> elements;

    public NodeBackedModelSet(ModelType<?> publicType, ModelType<T> elementType, ModelRuleDescriptor descriptor, MutableModelNode modelNode, ModelViewState state, ChildNodeInitializerStrategy<T> creatorStrategy) {
        this.publicType = publicType;
        this.elementType = elementType;

        ModelType<S> publicType = schema.getType();
        return schema instanceof ManagedImplSchema
            ? instanceFactory.getManagedSubtypeImplementationInfo(publicType)
            : instanceFactory.getImplementationInfo(publicType);
    }

    @Override
    public Iterable<ModelType<?>> supportedTypes() {

    private final ModelType<?> publicType;

    // Note: used by generated subtypes
    public NodeBackedModelMap(ModelType<?> publicType, ModelType<T> elementType, ModelRuleDescriptor sourceDescriptor, MutableModelNode modelNode,
                              ModelViewState viewState, ChildNodeInitializerStrategy<? super T> creatorStrategy) {

    open class KotlinJvmOptionsBase : KotlinJvmOptions

    interface KotlinJvmOptions

    private
    fun <T> extensionSchema(name: String, publicType: TypeOf<T>): ExtensionsSchema.ExtensionSchema = mock {
        on { getName() } doReturn name
        on { getPublicType() } doReturn publicType
    }

    private boolean generated;
    private Task generatorTask;

    public AbstractLanguageSourceSet(ComponentSpecIdentifier identifier, Class<? extends BuildableComponentSpec> publicType, SourceDirectorySet source) {
        super(identifier, publicType);
        this.source = source;
        super.builtBy(source.getBuildDependencies());
    }

    protected String getLanguageName() {
        return guessLanguageName(getTypeName());

    private DynamicObject afterConvention;
    private final DynamicObject extraPropertiesDynamicObject;

    public ExtensibleDynamicObject(Object delegate, Class<?> publicType, InstanceGenerator instanceGenerator) {
        this(delegate, createDynamicObject(delegate, publicType), new DefaultConvention(instanceGenerator));
    }

    }

    private <T extends ComponentSpec, I extends BaseComponentSpec> T create(Class<T> publicType, Class<I> implType) {
        return BaseComponentFixtures.create(publicType, implType, componentId)
    }

    def "library has name, path and sensible display name"() {
        when:
        def component = create(SampleComponent, MySampleComponent)

     */
    @Nullable
    <S extends T> ImplementationInfo getImplementationInfo(ModelType<S> publicType);

    /**
     * Return information about the implementation of a managed type with an unmanaged super-type.
     */
    <S extends T> ImplementationInfo getManagedSubtypeImplementationInfo(ModelType<S> publicType);

    interface ImplementationInfo {
        /**

    def "calculates display name from public type name"() {
        expect:
        def sourceSet = BaseLanguageSourceSet.create(publicType, BaseLanguageSourceSet, new DefaultComponentSpecIdentifier("project", "test"), TestUtil.objectFactory())
        sourceSet.displayName == displayName

        where:
        publicType                | displayName
        SomeTypeLanguageSourceSet | "SomeType source 'test'"

import org.gradle.platform.base.internal.BinaryNamingScheme;

public class TestNativeBinariesFactory {

    public static <T extends NativeBinarySpec, I extends AbstractNativeBinarySpec> T create(Class<T> publicType, Class<I> implType, String name, MutableModelNode componentNode,
                                                                                      BinaryNamingScheme namingScheme, NativeDependencyResolver resolver,