import org.gradle.plugin.management.internal.InvalidPluginRequestException;
import org.gradle.plugin.management.internal.PluginRequestInternal;

/**
 * A repository of plugins.
 */
public interface PluginResolver {
    /**
     * Resolve the given plugin request.
     *
     * @throws InvalidPluginRequestException If the plugin request was invalid.
     */

        // Resolve the plugin requests
        PluginResolver pluginResolver = wrapInAlreadyInClasspathResolver(classLoaderScope, resolveContext);
        for (PluginRequestInternal originalRequest : requests) {
            PluginRequestInternal request = pluginResolutionStrategy.applyTo(originalRequest);
            PluginResolution resolved = resolvePluginRequest(pluginResolver, request);

            resolved.accept(pluginDependencies);

import org.gradle.plugin.management.internal.PluginRequestInternal;

import java.util.List;

public class CompositePluginResolver implements PluginResolver {

    private final List<PluginResolver> repositories;

    public CompositePluginResolver(List<PluginResolver> repositories) {
        this.repositories = repositories;
    }

    @Override

    }

    public PluginResolver create(PluginArtifactRepositories pluginResolveContext) {
        return new CompositePluginResolver(createDefaultResolvers(pluginResolveContext));
    }

    private List<PluginResolver> createDefaultResolvers(PluginArtifactRepositories pluginResolveContext) {
        List<PluginResolver> resolvers = new LinkedList<>();

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

import org.gradle.plugin.use.resolve.internal.PluginResolver;

import java.util.Collection;

public interface ClientInjectedClasspathPluginResolver {
    ClientInjectedClasspathPluginResolver EMPTY = dest -> { };

    void collectResolversInto(Collection<? super PluginResolver> dest);

import org.gradle.plugin.use.resolve.internal.PluginResolutionVisitor;
import org.gradle.plugin.use.resolve.internal.PluginResolver;

import java.io.File;
import java.util.Collection;
import java.util.stream.Collectors;

public class DefaultInjectedClasspathPluginResolver implements ClientInjectedClasspathPluginResolver, PluginResolver {

    private final ClassPath injectedClasspath;
    private final FileCollectionFactory fileCollectionFactory;

import org.gradle.plugin.use.PluginId;
import org.gradle.plugin.use.resolve.internal.PluginResolution;
import org.gradle.plugin.use.resolve.internal.PluginResolutionResult;
import org.gradle.plugin.use.resolve.internal.PluginResolver;
import org.gradle.plugin.use.resolve.internal.PluginResolverContributor;

import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Resolves a plugin either by determining that it is already on the classpath
 * or by delegating to another resolver.
 */
public class AlreadyOnClasspathPluginResolver implements PluginResolver {
    private final PluginResolver delegate;
    private final PluginRegistry corePluginRegistry;
    private final PluginDescriptorLocator pluginDescriptorLocator;
    private final ClassLoaderScope parentLoaderScope;

import org.gradle.plugin.use.resolve.internal.ArtifactRepositoriesPluginResolver;
import org.gradle.plugin.use.resolve.internal.PluginArtifactRepositories;
import org.gradle.plugin.use.resolve.internal.PluginResolver;

import java.util.Objects;

class DefaultPluginArtifactRepositories implements PluginArtifactRepositories {
    private final DependencyResolutionServices dependencyResolutionServices;

 */
public interface PluginArtifactRepositories {
    PluginResolver getPluginResolver();

    void applyRepositoriesTo(RepositoryHandler repositories);