import org.gradle.internal.HasInternalProtocol;

/**
 * A TypeBuilder to configure the registration of a type.
 * @param <T> The registered type.
 */
@Incubating
@HasInternalProtocol
public interface TypeBuilder<T> {

    /**
     * Allows the plugin to register the implementation type.
     * @param implementation the implementation class.
     */
    TypeBuilder<T> defaultImplementation(Class<?> implementation);

    /**

        static void library(TypeBuilder<SomeLibrarySpec> builder) {
        }

        @ComponentType
        static void application(TypeBuilder<SomeApplicationSpec> builder) {
        }

        @ComponentType
        static void wildcardType(TypeBuilder<?> builder) {
        }

        @ComponentType
        static void extendsType(TypeBuilder<? extends ComponentSpec> builder) {
        }

            class MySamplePlugin extends RuleSource {
                @ComponentType
                void register(TypeBuilder<SampleComponent> builder) {
                }

                @ComponentType
                void registerAnother(TypeBuilder<SampleLibrary> builder) {
                    builder.defaultImplementation(DefaultSampleLibrary)
                }

                @Mutate

        }

        @ComponentType
        static void superType(TypeBuilder<? super BinarySpec> builder) {
        }

        @ComponentType
        static void notBinarySpec(TypeBuilder<NotBinarySpec> builder) {
        }

        @ComponentType
        static void notImplementingBinaryType(TypeBuilder<SomeBinarySpec> builder) {

        "wrongSubject"                | "A method annotated with @ComponentType must have a single parameter of type ${TypeBuilder.name}." | "wrong rule subject type"
        "rawLanguageTypeBuilder"      | "Parameter of type ${TypeBuilder.name} must declare a type parameter."                             | "non typed parameter"

            firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.a),
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.INCOMPATIBLE_TYPES) { firDiagnostic ->
        IncompatibleTypesImpl(
            firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.a),
            firSymbolBuilder.typeBuilder.buildKtType(firDiagnostic.b),

                @ComponentType
                void registerUnmanaged(TypeBuilder<UnmanagedComponentSpec> builder) {
                    builder.internalView(UnmanagedComponentSpecInternal)
                }

                @ComponentType
                void registerManaged(TypeBuilder<ManagedComponentSpec> builder) {
                    builder.internalView(ManagedComponentSpecInternal)

    @ComponentType
    void registerComponent(TypeBuilder<DocumentationComponent> builder) {}
// end::component-registration[]

// tag::binary-registration[]
    @ComponentType
    void registerBinary(TypeBuilder<DocumentationBinary> builder) {}
// end::binary-registration[]

// tag::text-lang-registration[]
    @ComponentType
    void registerText(TypeBuilder<TextSourceSet> builder) {}
// end::text-lang-registration[]

                @ComponentType
                void register(TypeBuilder<SampleBinary> builder) {
                }

                @Mutate
                void createSampleBinaryInstances(BinaryContainer binaries) {
                    binaries.create("sampleBinary", SampleBinary)
                }

                @ComponentType
                void registerAnother(TypeBuilder<AnotherSampleBinary> builder) {}

        interface NonRegisteredComponent extends SampleComponent {}

        class Rules extends RuleSource {
            @ComponentType
            void register1(TypeBuilder<SampleComponent> builder) {}
            @ComponentType
            void register2(TypeBuilder<Sample2Component> builder) {}
            @Model
            void things(ModelMap<SampleComponent> m) {}
        }
        apply plugin: Rules

        model {