public boolean visitEnter(DependencyNode node) {
            StringBuilder buffer = new StringBuilder(128);
            buffer.append(indent);
            org.eclipse.aether.graph.Dependency dep = node.getDependency();
            if (dep != null) {
                org.eclipse.aether.artifact.Artifact art = dep.getArtifact();
 
                buffer.append(art);
                if (StringUtils.isNotEmpty(dep.getScope())) {
                    buffer.append(':').append(dep.getScope());
                }
 
                if (dep.isOptional()) {
                    buffer.append(" (optional)");
                }
 
                // TODO We currently cannot tell which <dependencyManagement> section contained the management
                //      information. When the resolver provides this information, these log messages should be updated
                //      to contain it.
                if ((node.getManagedBits() & DependencyNode.MANAGED_SCOPE) == DependencyNode.MANAGED_SCOPE) {
                    final String premanagedScope = DependencyManagerUtils.getPremanagedScope(node);
                    buffer.append(" (scope managed from ");
                    buffer.append(Objects.toString(premanagedScope, "default"));
                    buffer.append(')');
                }
 
                if ((node.getManagedBits() & DependencyNode.MANAGED_VERSION) == DependencyNode.MANAGED_VERSION) {
                    final String premanagedVersion = DependencyManagerUtils.getPremanagedVersion(node);
                    buffer.append(" (version managed from ");
                    buffer.append(Objects.toString(premanagedVersion, "default"));
                    buffer.append(')');
                }
 
                if ((node.getManagedBits() & DependencyNode.MANAGED_OPTIONAL) == DependencyNode.MANAGED_OPTIONAL) {
                    final Boolean premanagedOptional = DependencyManagerUtils.getPremanagedOptional(node);
                    buffer.append(" (optionality managed from ");
                    buffer.append(Objects.toString(premanagedOptional, "default"));
                    buffer.append(')');
                }
 
                if ((node.getManagedBits() & DependencyNode.MANAGED_EXCLUSIONS) == DependencyNode.MANAGED_EXCLUSIONS) {
                    final Collection<org.eclipse.aether.graph.Exclusion> premanagedExclusions =
                            DependencyManagerUtils.getPremanagedExclusions(node);
 
                    buffer.append(" (exclusions managed from ");
                    buffer.append(Objects.toString(premanagedExclusions, "default"));
                    buffer.append(')');
                }
 
                if ((node.getManagedBits() & DependencyNode.MANAGED_PROPERTIES) == DependencyNode.MANAGED_PROPERTIES) {
                    final Map<String, String> premanagedProperties =
                            DependencyManagerUtils.getPremanagedProperties(node);
 
                    buffer.append(" (properties managed from ");
                    buffer.append(Objects.toString(premanagedProperties, "default"));
                    buffer.append(')');
                }
            }

private Artifact createArtifact(
            String groupId,
            String artifactId,
            VersionRange versionRange,
            String type,
            String classifier,
            String scope,
            String inheritedScope,
            boolean optional) {
        String desiredScope = Artifact.SCOPE_RUNTIME;
 
        if (inheritedScope == null) {
            desiredScope = scope;
        } else if (Artifact.SCOPE_TEST.equals(scope) || Artifact.SCOPE_PROVIDED.equals(scope)) {
            return null;
        } else if (Artifact.SCOPE_COMPILE.equals(scope) && Artifact.SCOPE_COMPILE.equals(inheritedScope)) {
            // added to retain compile artifactScope. Remove if you want compile inherited as runtime
            desiredScope = Artifact.SCOPE_COMPILE;
        }
 
        if (Artifact.SCOPE_TEST.equals(inheritedScope)) {
            desiredScope = Artifact.SCOPE_TEST;
        }
 
        if (Artifact.SCOPE_PROVIDED.equals(inheritedScope)) {
            desiredScope = Artifact.SCOPE_PROVIDED;
        }
 
        if (Artifact.SCOPE_SYSTEM.equals(scope)) {
            // system scopes come through unchanged...
            desiredScope = Artifact.SCOPE_SYSTEM;
        }
 
        ArtifactHandler handler = artifactHandlerManager.getArtifactHandler(type);
 
        return new DefaultArtifact(
                groupId, artifactId, versionRange, desiredScope, type, classifier, handler, optional);
    }

throws PluginManagerException, ComponentLookupException {
        MavenSession session = legacySupport.getSession();
 
        PluginDescriptor pluginDescriptor;
        try {
            pluginDescriptor = pluginManager.getPluginDescriptor(
                    plugin, session.getCurrentProject().getRemotePluginRepositories(), session.getRepositorySession());
 
            pluginManager.setupPluginRealm(pluginDescriptor, session, null, null, null);
        } catch (Exception e) {
            throw new PluginManagerException(plugin, e.getMessage(), e);
        }
 
        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(pluginDescriptor.getClassRealm());
 
            return container.lookup(role, roleHint);

}
 
    private static String format(LocalRepository localRepository, List<RemoteRepository> remoteRepositories) {
        String repos = "[";
 
        if (localRepository != null) {
            repos += localRepository.getId() + " (" + localRepository.getBasedir() + ")";
        }
 
        if (remoteRepositories != null && !remoteRepositories.isEmpty()) {
            for (RemoteRepository repository : remoteRepositories) {
                repos += ", ";
 
                if (repository != null) {
                    repos += repository.getId() + " (" + repository.getUrl() + ")";
                }
            }
        }
 
        repos += "]";
 
        return repos;
    }
}

|| Artifact.SCOPE_SYSTEM.equals(a.getScope())) {
                Dependency dependency = new Dependency();
 
                dependency.setArtifactId(a.getArtifactId());
                dependency.setGroupId(a.getGroupId());
                dependency.setVersion(a.getVersion());
                dependency.setScope(a.getScope());
                dependency.setType(a.getType());
                dependency.setClassifier(a.getClassifier());
 
                list.add(dependency);
            }
        }
        return Collections.unmodifiableList(list);
    }
 
    @Deprecated
    public List<Artifact> getTestArtifacts() {

|| Artifact.SCOPE_SYSTEM.equals(a.getScope())) {
                Dependency dependency = new Dependency();
 
                dependency.setArtifactId(a.getArtifactId());
                dependency.setGroupId(a.getGroupId());
                dependency.setVersion(a.getVersion());
                dependency.setScope(a.getScope());
                dependency.setType(a.getType());
                dependency.setClassifier(a.getClassifier());
 
                list.add(dependency);
            }
        }
        return Collections.unmodifiableList(list);
    }
 
    @Deprecated
    public List<Artifact> getTestArtifacts() {