Class<?> publicType = getPublicType();
        boolean includeDisplayName = hasUsefulDisplayName();
        if (publicType != null && includeDisplayName) {
            return new MissingPropertyException(String.format("Could not set unknown property '%s' for %s of type %s.", name,
                    getDisplayName(), publicType.getName()), name, publicType);
        } else if (publicType != null) {

        def node = createNode(publicType, implType, componentId);
        return node.asMutable(ModelType.of(publicType), new SimpleModelRuleDescriptor(componentId.getName())).getInstance()
    }

        public final Class<?> publicType;

        private ComponentInfo(
            ComponentSpecIdentifier componentIdentifier,
            MutableModelNode modelNode,
            Class<?> publicType
        ) {
            this.componentIdentifier = componentIdentifier;
            this.modelNode = modelNode;
            this.publicType = publicType;
        }
    }

    }

    public <S extends PUBLIC> TypeRegistrationBuilder<S> register(ModelType<S> publicType, ModelRuleDescriptor source) {
        TypeRegistration<S> registration = Cast.uncheckedCast(registrations.get(publicType));
        if (registration == null) {
            registration = new TypeRegistration<S>(publicType);
            registrations.put(publicType, registration);
        }

public class AbstractComponentSpec implements ComponentSpec, ComponentSpecInternal {
    private final ComponentSpecIdentifier identifier;
    private final Class<?> publicType;

    public AbstractComponentSpec(ComponentSpecIdentifier identifier, Class<?> publicType) {
        this.publicType = publicType;
        this.identifier = identifier;
    }

    @Override
    public ComponentSpecIdentifier getIdentifier() {
        return identifier;

        private final Class<? extends LanguageSourceSet> publicType;
        private final ObjectFactory objectFactory;

        private SourceSetInfo(ComponentSpecIdentifier identifier, Class<? extends LanguageSourceSet> publicType, ObjectFactory objectFactory) {
            this.identifier = identifier;
            this.publicType = publicType;
            this.objectFactory = objectFactory;
        }
    }

        propertyMetadata.getAnnotation(SoftwareType.class).ifPresent(softwareType -> {
            Class<?> publicType = softwareType.modelPublicType();
            Class<?> valueType = propertyMetadata.getDeclaredType().getRawType();
            if (publicType != Void.class && !publicType.isAssignableFrom(valueType)) {
                validationContext.visitPropertyProblem(problem ->
                    problem

    private final String description;
    private final ChangeType publicType;

    ChangeTypeInternal(String description, ChangeType publicType) {
        this.description = description;
        this.publicType = publicType;
    }

    public String describe() {
        return description;
    }

    public ChangeType getPublicType() {
        return publicType;
    }

    private static final ModelType<ModelElement> MODEL_ELEMENT_MODEL_TYPE = ModelType.of(ModelElement.class);
    private final ModelType<?> publicType;

    public ModelElementProjection(ModelType<?> publicType) {
        super(MODEL_ELEMENT_MODEL_TYPE);
        this.publicType = publicType;
    }

    @Override

    SomeType newInstance(Class<? extends SomeType> implType, Class<? extends SomeType> publicType, SomeType target) {
        def generated = generate(implType, publicType)
        return generated.newInstance(target)
    }

    Class<? extends SomeType> generate(Class<? extends SomeType> implType, Class<? extends SomeType> publicType) {
        def generated = classes[publicType]
        if (generated == null) {