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);

    /**

        }

        @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"

    @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[]

    override val first
        get(): KaSubstitutor {
            return builder.typeBuilder.buildSubstitutor(substitutor.first)
        }

    override val second
        get(): KaSubstitutor {
            return builder.typeBuilder.buildSubstitutor(substitutor.second)
        }

import org.gradle.platform.base.ComponentType
import org.gradle.platform.base.TypeBuilder
import sample.documentation.DocumentationBinary

// tag::markdown-lang-registration[]
// tag::markdown-tasks-generation[]
class MarkdownPlugin extends RuleSource {
// end::markdown-tasks-generation[]
    @ComponentType
    void registerMarkdownLanguage(TypeBuilder<MarkdownSourceSet> builder) {}
// end::markdown-lang-registration[]

private fun List<FirTypeRef>.mapToKtType(
    builder: KaSymbolByFirBuilder,
): List<KaType> = map { typeRef ->
    builder.typeBuilder.buildKtType(typeRef)
}

internal fun FirCallableSymbol<*>.returnType(builder: KaSymbolByFirBuilder): KaType =
    builder.typeBuilder.buildKtType(resolvedReturnType)

internal fun FirCallableSymbol<*>.receiver(builder: KaSymbolByFirBuilder): KaReceiverParameterSymbol? =

        @Managed interface CustomLanguageSourceSet extends LanguageSourceSet {}

        class CustomLanguagePlugin extends RuleSource {
            @ComponentType
            void declareCustomLanguage(TypeBuilder<CustomLanguageSourceSet> builder) {
            }
        }

        apply plugin:CustomLanguagePlugin
"""
    }

    def "can add custom language sourceSet to component"() {
        when:

            @Managed interface CustomComponent extends GeneralComponentSpec {}

            class ComponentTypeRules extends RuleSource {
                @ComponentType
                void registerCustomComponentType(TypeBuilder<CustomComponent> builder) {}
            }

            apply type: ComponentTypeRules
        """
    }

    /**
     * Registers CustomBinary type
     */
    void withCustomBinaryType() {

        @ComponentType
        public void registerGoogleTestSuiteSpecTest(TypeBuilder<GoogleTestTestSuiteSpec> builder) {
            builder.defaultImplementation(DefaultGoogleTestTestSuiteSpec.class);
        }

        @ComponentType
        public void registerGoogleTestSuiteBinaryType(TypeBuilder<GoogleTestTestSuiteBinarySpec> builder) {