setArtifactDependencies(artifacts)
                .setManagedVersionMap(managedVersions)
                .setLocalRepository(localRepository)
                .setRemoteRepositories(remoteRepositories)
                .setCollectionFilter(filter)
                .setListeners(listeners);

        injectSession2(request, legacySupport.getSession());

        copy.setLoggingLevel(original.getLoggingLevel());
        copy.setGlobalChecksumPolicy(original.getGlobalChecksumPolicy());
        copy.setUpdateSnapshots(original.isUpdateSnapshots());
        copy.setRemoteRepositories(original.getRemoteRepositories());
        copy.setPluginArtifactRepositories(original.getPluginArtifactRepositories());
        copy.setRepositoryCache(original.getRepositoryCache());

     *
     * @param repositories
     * @return This request, never {@code null}.
     */
    MavenExecutionRequest setRemoteRepositories(List<ArtifactRepository> repositories);

    List<ArtifactRepository> getRemoteRepositories();

    MavenExecutionRequest setPluginArtifactRepositories(List<ArtifactRepository> repositories);

            throws ArtifactResolutionException, ArtifactNotFoundException {
        RepositoryRequest request = new DefaultRepositoryRequest();
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        transformForResolve(artifact, request);
    }

    protected String resolveVersion(

        injectSession(request);
        request.setArtifact(artifact);
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        request.setResolveManagedVersions(resolveManagedVersions);
        return retrieve(request);
    }

    @Override

                request.setUserProperties(session.getUserProperties());
            }

            MavenExecutionRequest req = session.getRequest();
            if (req != null) {
                request.setRemoteRepositories(req.getRemoteRepositories());
            }
        } else {
            Properties props = new Properties();
            EnvironmentUtils.addEnvVars(props);
            props.putAll(System.getProperties());

        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();
        configuration.setLocalRepository(getLocalRepository());
        configuration.setRemoteRepositories(Arrays.asList(new ArtifactRepository[] {}));
        configuration.setProcessPlugins(true);
        configuration.setResolveDependencies(true);
        initRepoSession(configuration);

        try {

            request.setArtifactDependencies(project.getDependencyArtifacts());
            request.setManagedVersionMap(project.getManagedVersionMap());
            request.setRemoteRepositories(project.getRemoteArtifactRepositories());

            ArtifactResolutionResult result = repositorySystem.resolve(request);

            try {
                resolutionErrorHandler.throwErrors(request, result);

            List<ConflictResolver> conflictResolvers) {
        ArtifactResolutionRequest request = new ArtifactResolutionRequest();
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        injectSession(request);
        return collect(
                artifacts, originatingArtifact, managedVersions, request, source, filter, listeners, conflictResolvers);
    }

            throws RepositoryMetadataResolutionException {
        RepositoryRequest request = new DefaultRepositoryRequest();
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        resolve(metadata, request);
    }

    @Override
    public void resolve(RepositoryMetadata metadata, RepositoryRequest request)