// even before the arguments from the command line are parsed.  Any exception
            // that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being
            // displayed to the user, so just bail out and return false.
        }
        return false;
    }

        if (lookup == null) {
            return customLifecycles != null ? customLifecycles : new HashMap<>();
        }

        // Lifecycles cannot be cached as extensions might add custom lifecycles later in the execution.
        try {
            Map<String, Lifecycle> lifecycles = new HashMap<>(lookup.lookupMap(Lifecycle.class));
            for (org.apache.maven.api.Lifecycle lf : registry) {

            /*
             * Module hierarchy: many modules, one per directory, with descriptor at the root of the sub-directory.
             * This is the layout of output directories in projects using the new (Java 9 and later) way to organize
             * source files.
             */
            if (Files.isDirectory(file)) {
                Map<Path, String> names = new HashMap<>();

            // Maven 3.x is always using 4.0.0 version to load the supermodel, so
            // do the same when loading a dependency.  The model validator will also
            // check that field later.
            superModelVersion = "4.0.0";
        }
        ModelData superData = new ModelData(null, getSuperModel(superModelVersion));

        // profile activation

            // previously we cloned the artifact, but it is more efficient to just update the artifactScope
            // if problems are later discovered that the original object needs its original artifactScope value,
            // cloning may
            // again be appropriate
            nearestArtifact.setScope(farthestArtifact.getScope());
        }

            /*
             * Module hierarchy: many modules, one per directory, with descriptor at the root of the sub-directory.
             * This is the layout of output directories in projects using the new (Java 9 and later) way to organize
             * source files.
             */
            if (Files.isDirectory(file)) {
                Map<Path, String> names = new HashMap<>();

/**
 * Component for use by the <code>maven-toolchains-plugin</code> only.
 * It provides API: <ol>
 * <li>to retrieve every toolchains available in user settings,</li>
 * <li>to store chosen toolchain into build context for later use by toolchain-aware plugins.</li>
 * </ol>
 *
 * @since 2.0.9
 * @see ToolchainManager#getToolchainFromBuildContext(String, MavenSession)
 */
public interface ToolchainManagerPrivate {

    /**

                     * happens, add on class-path or module-path if allowed, or keep patching otherwise.
                     * The latter case (keep patching) is okay if the main module will be defined later.
                     */
                    type = cache.selectPathType(pathTypes, filter, path).orElse(type);
                }
                addPathElement(type, info.getKey());

                }
            }

            Severity errOn30 = getSeverity(request, ModelBuilderRequest.VALIDATION_LEVEL_MAVEN_3_0);

            // The file pom may not contain the modelVersion yet, as it may be set later by the
            // ModelVersionXMLFilter.
            if (m.getModelVersion() != null && !m.getModelVersion().isEmpty()) {
                validateModelVersion(problems, m.getModelVersion(), m, VALID_MODEL_VERSIONS);