abstract class MadeUpPlugin implements Plugin<Settings> {

    @Inject
    protected abstract JavaToolchainResolverRegistry getToolchainResolverRegistry();

    void apply(Settings settings) {
        settings.getPlugins().apply("jvm-toolchain-management")

        JavaToolchainResolverRegistry registry = getToolchainResolverRegistry()
        registry.register(MadeUpResolver.class)
    }
}

    @Inject
    protected abstract JavaToolchainResolverRegistry getToolchainResolverRegistry(); // <2>

    public void apply(Settings settings) {
        settings.getPlugins().apply("jvm-toolchain-management"); // <3>

        JavaToolchainResolverRegistry registry = getToolchainResolverRegistry();
        registry.register(JavaToolchainResolverImplementation.class);
    }
}

public class InhouseStrongOpinionConventionJavaPlugin implements Plugin<Project> {
    public void apply(Project project) {
        // Careful! Eagerly appyling plugins has downsides, and is not always recommended.
        project.getPlugins().apply(JavaPlugin.class);
        SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
        SourceSet main = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME);

        }

        if (model != null) {
            Build build = model.getBuild();
            if (build != null) {
                for (Plugin plugin : build.getPlugins()) {
                    if (groupId.equals(plugin.getGroupId()) && artifactId.equals(plugin.getArtifactId())) {
                        return plugin;
                    }
                }

                PluginContainer source,
                boolean sourceDominant,
                Map<Object, Object> context) {
            List<Plugin> src = source.getPlugins();
            if (!src.isEmpty()) {
                List<Plugin> tgt = target.getPlugins();
                Map<Object, Plugin> master = new LinkedHashMap<>(src.size() * 2);

                for (Plugin element : src) {

            if (autoAppliedPlugins.isEmpty()) {
                return PluginRequests.EMPTY;
            }
            return filterAlreadyAppliedOrRequested(autoAppliedPlugins, initialRequests, project.getPlugins(), project.getBuildscript());
        } else if (pluginTarget instanceof Settings) {
            Settings settings = (Settings) pluginTarget;

import org.gradle.api.plugins.PluginManager


open class PluginAwareScript internal constructor(
    private val host: KotlinScriptHost<PluginAware>
) : PluginAware {

    override fun getPlugins(): PluginContainer =
        host.target.plugins

    override fun getPluginManager(): PluginManager =
        host.target.pluginManager

    override fun apply(action: Action<in ObjectConfigurationAction>) =

        Model.Builder builder = Model.newBuilder(model);

        Build build = model.getBuild();
        if (build != null) {
            List<Plugin> plugins = build.getPlugins();
            Map<Object, Plugin> normalized = new LinkedHashMap<>(plugins.size() * 2);

            for (Plugin plugin : plugins) {
                Object key = plugin.getKey();

    private final Set<File> libConfigFiles;

    public WtpClasspathAttributeSupport(Project project, EclipseModel model) {
        isUtilityProject = !project.getPlugins().hasPlugin(WarPlugin.class) && !project.getPlugins().hasPlugin(EarPlugin.class);
        EclipseWtp eclipseWtp = model.getWtp();
        EclipseWtpComponent wtpComponent = eclipseWtp.getComponent();
        libDirName = wtpComponent.getLibDeployPath();

    private void configureForSwiftPlugin(final Project project) {
        project.getPlugins().withType(SwiftApplicationPlugin.class, new Action<SwiftApplicationPlugin>() {
            @Override
            public void execute(SwiftApplicationPlugin plugin) {
                configureXcodeForSwift(project);
            }
        });

        project.getPlugins().withType(SwiftLibraryPlugin.class, new Action<SwiftLibraryPlugin>() {