*/

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

            Map<PluginIdLookupCacheKey, Optional<PluginImplementation<?>>> idToPlugin = idMappings.asMap();
            PluginImplementation<?> lookup = impl.get();
            ImmutableSortedSet.Builder<PluginId> builder = ImmutableSortedSet.orderedBy(Comparator.comparing(PluginId::getId));
            for (Map.Entry<PluginIdLookupCacheKey, Optional<PluginImplementation<?>>> entry : idToPlugin.entrySet()) {

        PluginImplementation<?> pluginImplementation = plugins.get(plugin);
        if (pluginImplementation != null) {
            return Optional.ofNullable(pluginImplementation.getPluginId());
        }
        return Optional.empty();
    }

    @Override
    public void apply(PluginImplementation<?> plugin) {
        doApply(plugin);
    }

    @Override

import org.gradle.api.internal.plugins.PluginImplementation;
import org.gradle.api.internal.plugins.PluginManagerInternal;
import org.gradle.plugin.use.PluginId;

import javax.annotation.Nullable;

public class ClassPathPluginResolution implements PluginResolution {

    private final PluginId pluginId;
    private final String pluginVersion;
    private final PluginImplementation<?> plugin;

import java.util.Optional;

@ThreadSafe
public interface PluginRegistry {
    <T> PluginImplementation<T> inspect(Class<T> clazz);

    /**
     * Extracts plugin information for the given class, if known to this registry.
     */
    @Nullable
    <T> PluginImplementation<T> maybeInspect(Class<T> clazz);

    /**

import org.gradle.api.internal.plugins.PluginImplementation;
import org.gradle.api.internal.plugins.PluginManagerInternal;
import org.gradle.plugin.use.PluginId;

public class SimplePluginResolution implements PluginResolution {
    private final PluginImplementation<?> plugin;

    public SimplePluginResolution(PluginImplementation<?> plugin) {
        this.plugin = plugin;
    }

    @Override

                }
            }
        """
        producer.file('src/main/java/example/plugin/GreetingPlugin.java') << pluginImplementation('<7.0')
        producer.file('src/gradle7/java/example/plugin/GreetingPlugin.java') << pluginImplementation('7.0+')

        consumer.file('settings.gradle') << """
            pluginManagement {
                repositories {

import org.gradle.plugin.use.PluginId;

import java.util.Optional;

public interface PluginManagerInternal extends PluginManager {
    void apply(PluginImplementation<?> plugin);

    <P extends Plugin> P addImperativePlugin(PluginImplementation<P> plugin);

    <P extends Plugin> P addImperativePlugin(Class<P> plugin);

    PluginContainer getPluginContainer();

        return "Gradle TestKit";
    }

    private static class InjectedClasspathPluginResolution implements PluginResolution {
        private final PluginImplementation<?> plugin;

        public InjectedClasspathPluginResolution(PluginImplementation<?> plugin) {
            this.plugin = plugin;
        }

        @Override
        public PluginId getPluginId() {
            return plugin.getPluginId();

 * limitations under the License.
 */

package org.gradle.plugin.use.resolve.internal;

import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.api.internal.plugins.PluginImplementation;
import org.gradle.api.internal.plugins.PluginRegistry;
import org.gradle.plugin.management.internal.InvalidPluginRequestException;
import org.gradle.plugin.management.internal.PluginRequestInternal;