*
 * This may represent an invalid plugin.
 *
 * At the moment it does not encompass plugins that aren't implemented as classes, but it is likely to in the future.
 */
public interface PotentialPlugin<T> {

    enum Type {
        UNKNOWN,
        IMPERATIVE_CLASS,
        PURE_RULE_SOURCE_CLASS,
        HYBRID_IMPERATIVE_AND_RULES_CLASS
    }

    Class<? extends T> asClass();

    }

    private <T extends Plugin<?>> PotentialPlugin<T> toImperative(Class<T> type, boolean hasRules) {
        if (hasRules) {
            return new PotentialHybridImperativeAndRulesPlugin<T>(type);
        } else {
            return new PotentialImperativeClassPlugin<T>(type);
        }
    }

    private static class PotentialImperativeClassPlugin<T extends Plugin<?>> implements PotentialPlugin<T> {

    private final PluginId pluginId;
    private final PotentialPlugin<? extends T> potentialPlugin;

    public static <T> DefaultPotentialPluginWithId<T> of(PluginId pluginId, PotentialPlugin<T> potentialPlugin) {
        return new DefaultPotentialPluginWithId<T>(pluginId, potentialPlugin);
    }

    protected DefaultPotentialPluginWithId(PluginId pluginId, PotentialPlugin<? extends T> potentialPlugin) {
        this.pluginId = pluginId;

                        pluginDescriptor), e);
                }

                PotentialPlugin<?> potentialPlugin = pluginInspector.inspect(implClass);
                PluginImplementation<Object> withId = new RegistryAwarePluginImplementation(classLoader, pluginId, potentialPlugin);
                return Optional.of(withId);
            }
        });
    }

    @Override

        expect:
        def plugin = pluginRegistry.lookup(DefaultPluginId.of("somePlugin"))
        plugin.pluginId == DefaultPluginId.of("somePlugin")
        plugin.type == PotentialPlugin.Type.IMPERATIVE_CLASS
        plugin.displayName.displayName == "plugin 'somePlugin'"
        plugin.asClass() == TestPlugin1
    }

    def "can locate rule source plugin implementation given an id"() {

package org.gradle.api.internal.plugins;

import org.gradle.internal.DisplayName;
import org.gradle.plugin.use.PluginId;

import javax.annotation.Nullable;

public interface PluginImplementation<T> extends PotentialPlugin<T> {
    DisplayName getDisplayName();

    /**
     * An id for the plugin implementation, if known.
     */
    @Nullable
    PluginId getPluginId();

    boolean isAlsoKnownAs(PluginId id);

        try {
            Thread.currentThread().setContextClassLoader(pluginClass.getClassLoader());
            if (plugin.getType().equals(PotentialPlugin.Type.UNKNOWN)) {
                throw new InvalidPluginException("'" + pluginClass.getName() + "' is neither a plugin or a rule source and cannot be applied.");
            } else {

Class <org.gradle.api.internal.plugins.PotentialPlugin$Type> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (PotentialPlugin.java:0)
Class <org.gradle.api.internal.plugins.PotentialPlugin> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (PotentialPlugin.java:0)