pluginArtifact = pluginArtifact.setProperties(props);
            }
        } catch (ArtifactDescriptorException e) {
            throw new PluginResolutionException(plugin, e.getResult().getExceptions(), e);
        }

        try {
            ArtifactRequest request = new ArtifactRequest(pluginArtifact, repositories, REPOSITORY_CONTEXT);
            request.setTrace(trace);

        return this;
    }

    @Override
    public List<Throwable> getExceptions() {
        return exceptions;
    }

    @Override
    public MavenExecutionResult addException(Throwable t) {
        exceptions.add(t);

        return this;
    }

    @Override
    public boolean hasExceptions() {
        return !getExceptions().isEmpty();
    }

    @Override

            result.setDependencyGraph(node);
        } catch (DependencyCollectionException e) {
            result.setDependencyGraph(e.getResult().getRoot());
            result.setCollectionErrors(e.getResult().getExceptions());

            throw new DependencyResolutionException(
                    result, "Could not collect dependencies for project " + project.getId(), e);
        }

        depRequest.setRoot(node);

        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),
                    request.getArtifact(),
                    request.getRemoteRepositories());
        }
    }

    private static <T> List<T> toList(Collection<T> items) {

            validateOptionalProfiles(session, request.getProfileActivation());

            if (session.getResult().hasExceptions()) {
                addExceptionToResult(result, session.getResult().getExceptions().get(0));
                persistResumptionData(result, session);
                return result;
            } else {
                session.getAllProjects().stream()

                System.err.println("Missing: " + artifact);
            }
        }

        if (result.hasExceptions()) {
            for (Exception e : result.getExceptions()) {
                e.printStackTrace();
            }
        }
    }

    // ------------------------------------------------------------------------

    public boolean hasExceptions() {
        return exceptions != null && !exceptions.isEmpty();
    }

    public List<Exception> getExceptions() {
        return exceptions == null ? Collections.emptyList() : Collections.unmodifiableList(exceptions);
    }

    // ------------------------------------------------------------------------

    // ------------------------------------------------------------------------

    public boolean hasExceptions() {
        return exceptions != null && !exceptions.isEmpty();
    }

    public List<Exception> getExceptions() {
        return exceptions == null ? Collections.emptyList() : Collections.unmodifiableList(exceptions);
    }

    // ------------------------------------------------------------------------

            if ((i == lines.length - 1)
                    && (context.options().showErrors().orElse(false)
                            || (summary.getException() instanceof InternalErrorException))) {
                context.logger.error(line, summary.getException());
            } else {
                context.logger.error(line);
            }

            currentColor = nextColor;
        }

            line = indent + line + ("".equals(nextColor) ? "" : ANSI_RESET);

            if ((i == lines.length - 1) && (showErrors || (summary.getException() instanceof InternalErrorException))) {
                slf4jLogger.error(line, summary.getException());
            } else {
                slf4jLogger.error(line);
            }

            currentColor = nextColor;
        }