Method <org.gradle.plugin.devel.GradlePluginDevelopmentExtension.getPlugins()> does not have raw return type assignable to org.gradle.api.provider.Provider in (GradlePluginDevelopmentExtension.java:0)

        assert actual == version
    }

    void hasPlugin(String alias, String id, String version) {
        assert model.hasPlugin(alias)
        def plugin = model.getPlugin(alias)
        assert plugin != null : "Expected a plugin with alias '$alias' but it wasn't found"
        assert plugin.id == id
        assert plugin.version.requiredVersion == version
    }

        if (aliases.isEmpty()) {
            return;
        }
        writeTableHeader("plugins");
        for (String alias : aliases) {
            PluginModel data = model.getPlugin(alias);
            String id = data.getId();
            String versionRef = data.getVersionRef();
            ImmutableVersionConstraint version = data.getVersion();
            StringBuilder sb = new StringBuilder();

            final MojoExecution mojoExecution = executionPlanItem.getMojoExecution();
            if (!mojoExecution.getMojoDescriptor().isThreadSafe()) {
                plugins.add(mojoExecution.getPlugin());
            }
        }
        return plugins;
    }

    /**
     * Get set of mojos used but not marked @threadSafe
     *
     * @return the set of mojo descriptors
     */

            this.plugin = plugin;
        }

        public long getApplicationId() {
            return applicationId;
        }

        public InternalPluginIdentifier getPlugin() {
            return plugin;
        }

    }

            }
            operations << "applying"
            apply plugin: '$appliedBy'
            operations << "applied"

            assert plugins["$detectedBy"]
            assert plugins.getPlugin("$detectedBy")
            assert pluginManager.hasPlugin("$detectedBy")
            assert pluginManager.findPlugin("$detectedBy").id == "$detectedBy"

            task verify {
                doLast {

                            .map(ModelProblem::getException)
                            .filter(pluginArtifactNotFoundException)
                            .map(exc -> ((PluginResolutionException) exc.getCause()).getPlugin())
                            .anyMatch(isPluginPartOfRequestScope);
                })
                .orElse(false);
    }

                PluginModel plugin = config.getPlugin(path);
                writePlugin(path, plugin, true);
            }
            for (String alias : aliases) {
                String childName = leafNodeForAlias(alias);
                if (!classNode.hasChild(childName)) {
                    PluginModel plugin = config.getPlugin(alias);
                    writePlugin(alias, plugin, false);

        InputSource defaultBindings = new InputSource();
        defaultBindings.setModelId(DefaultLifecyclePluginAnalyzer.DEFAULTLIFECYCLEBINDINGS_MODELID);

        final Plugin plugin = mojoDescriptor.getPluginDescriptor().getPlugin();
        plugin.setLocation("version", new InputLocation(12, 34, defaultBindings));
        MojoExecution result = new MojoExecution(plugin, goal, executionId);

            convention.plugins["my"] = objects.newInstance<MyConvention>()
            tasks.register("noop")
        """)
        withBuildScript("""
            plugins { id("my-plugin") }

            convention.getPlugin(MyConvention::class).some("api.get")
            the<MyConvention>().some("kotlin.reified.get")
            the(MyConvention::class).some("kotlin.kclass.get")
            configure<MyConvention> { some("kotlin.configure") }