// TODO Should this be changed for MNG-6754 too?
            snapshot.setTimestamp(getDeploymentTimestamp());

            // we update the build number anyway so that it doesn't get lost. It requires the timestamp to take effect
            try {
                int buildNumber = resolveLatestSnapshotBuildNumber(artifact, localRepository, remoteRepository);

                snapshot.setBuildNumber(buildNumber + 1);

            legacySupport.setSession(oldSession);
        }
    }

    /**
     * TODO pluginDescriptor classRealm and artifacts are set as a side effect of this
     *      call, which is not nice.
     * @throws PluginResolutionException
     */
    public ClassRealm getPluginRealm(MavenSession session, PluginDescriptor pluginDescriptor)

 *
 * A side effect of using @Typed is that it translates to explicit bindings in the container.
 * So instead of binding the component under a 'wildcard' key it is now bound with an explicit
 * key. Since this is a default component this will be a plain binding of ModelProcessor to
 * this implementation type, ie. no hint/name.
 *
 * This leads to a second side effect in that any @Inject request for just ModelProcessor in

    // required after the execution of 9) as the AbstractLifecycleParticipants are free to mutate the MavenProject
    // instances, which may change dependencies which can, in turn, affect the build order.
    //
    // 11) Execute LifecycleStarter.start()
    //
    @SuppressWarnings("checkstyle:methodlength")
    private MavenExecutionResult doExecute(MavenExecutionRequest request) {

            addViolation(
                    problems,
                    BuilderProblem.Severity.WARNING,
                    "usePluginRegistry",
                    null,
                    "is deprecated and has no effect.");
        }

        List<String> pluginGroups = settings.getPluginGroups();

        if (pluginGroups != null) {
            for (int i = 0; i < pluginGroups.size(); i++) {

 * probably roll its own.
 * <p>
 * This implementation is backed by Maven Resolver API, supported protocols and transport selection depends on it. If
 * resolver preference regarding transport is altered, it will affect this service as well.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface TransportProvider extends Service {
    /**

                            + newRepos.stream().map(s -> "    " + s).collect(Collectors.joining("\n")));
                }
            }

            // we pass a cloned model, so that resolving the parent version does not affect the returned model
            ModelData parentData = readParent(model, currentData.source(), request, problems);

            if (parentData == null) {
                currentData = superData;

         * Adds the specified managed dependency.
         *
         * @param managedDependency The managed dependency to add, may be {@code null} in which case the call
         *                          will have no effect.
         * @return this request for chaining, never {@code null}
         */
        @Nonnull
        public DependencyCollectorRequestBuilder managedDependency(@Nullable DependencyCoordinate managedDependency) {

    /**
     * Returns a filter for only the core artifacts.
     *
     * @return the artifact filter
     */
    ArtifactFilter getCoreArtifactFilter();

    /**
     * Exclude an extension artifact (doesn't affect getArtifactFilter's result, only getExtensionArtifactFilter).
     *
     * @param artifactId an artifact id
     * @deprecated use {@code META-INF/maven/extension.xml} to define artifacts exported by Maven core and plugin

        return result;
    }

    private static boolean policyEquals(RepositoryPolicy p1, RepositoryPolicy p2) {
        if (p1 == p2) {
            return true;
        }
        // update policy doesn't affect contents
        return p1.isEnabled() == p2.isEnabled() && Objects.equals(p1.getChecksumPolicy(), p2.getChecksumPolicy());
    }

    private static boolean repositoryEquals(RemoteRepository r1, RemoteRepository r2) {