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? =

        static class ComponentModel extends RuleSource {
            @ComponentType
            void registerLibrary(TypeBuilder<SampleLibrary> builder) {}

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

            @ComponentType
            void registerSourceSet(TypeBuilder<LibrarySourceSet> builder) {
            }
        }
    }

    apply plugin:MyBinaryDeclarationModel
"""

        @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) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.language.base.internal;

import org.gradle.platform.base.TypeBuilder;

public interface SomeOtherBuilder<T> extends TypeBuilder<T> {

            @Variant
            Integer getVariantProp()
            void setVariantProp(Integer variant)
        }
        class Rules extends RuleSource {
            @ComponentType
            void register(TypeBuilder<SampleBinary> builder) {}
        }
        apply plugin: Rules
        """

        expect:
        fails "components"

    @ComponentType
    void registerTestSuiteType(TypeBuilder<CustomTestSuite> builder) {
        builder.defaultImplementation(DefaultCustomTestSuite)
    }

    @ComponentType
    void registerBinaryType(TypeBuilder<CustomTestBinary> builder) {
        builder.defaultImplementation(DefaultCustomTestBinary)
    }

    @ComponentType
    void registerLanguageType(TypeBuilder<CustomTestSourceSet> builder) {
    }

    @Mutate