8187443: Forest Consolidation: Move files to unified layout

Reviewed-by: darcy, ihse

src/java.base/share/classes/java/lang/module/Resolver.java

@@ -0,0 +1,911 @@
+/*
+ * Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.lang.module;
+
+import java.io.PrintStream;
+import java.lang.module.ModuleDescriptor.Provides;
+import java.lang.module.ModuleDescriptor.Requires.Modifier;
+import java.net.URI;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import jdk.internal.module.ModuleHashes;
+import jdk.internal.module.ModuleReferenceImpl;
+import jdk.internal.module.ModuleTarget;
+
+/**
+ * The resolver used by {@link Configuration#resolve} and {@link
+ * Configuration#resolveAndBind}.
+ *
+ * @implNote The resolver is used at VM startup and so deliberately avoids
+ * using lambda and stream usages in code paths used during startup.
+ */
+
+final class Resolver {
+
+    private final ModuleFinder beforeFinder;
+    private final List<Configuration> parents;
+    private final ModuleFinder afterFinder;
+    private final PrintStream traceOutput;
+
+    // maps module name to module reference
+    private final Map<String, ModuleReference> nameToReference = new HashMap<>();
+
+    // true if all automatic modules have been found
+    private boolean haveAllAutomaticModules;
+
+    // constraint on target platform
+    private String targetPlatform;
+
+    String targetPlatform() { return targetPlatform; }
+
+    /**
+     * @throws IllegalArgumentException if there are more than one parent and
+     *         the constraints on the target platform conflict
+     */
+    Resolver(ModuleFinder beforeFinder,
+             List<Configuration> parents,
+             ModuleFinder afterFinder,
+             PrintStream traceOutput) {
+        this.beforeFinder = beforeFinder;
+        this.parents = parents;
+        this.afterFinder = afterFinder;
+        this.traceOutput = traceOutput;
+
+        // record constraint on target platform, checking for conflicts
+        for (Configuration parent : parents) {
+            String value = parent.targetPlatform();
+            if (value != null) {
+                if (targetPlatform == null) {
+                    targetPlatform = value;
+                } else {
+                    if (!value.equals(targetPlatform)) {
+                        String msg = "Parents have conflicting constraints on target" +
+                                     "  platform: " + targetPlatform + ", " + value;
+                        throw new IllegalArgumentException(msg);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Resolves the given named modules.
+     *
+     * @throws ResolutionException
+     */
+    Resolver resolve(Collection<String> roots) {
+
+        // create the visit stack to get us started
+        Deque<ModuleDescriptor> q = new ArrayDeque<>();
+        for (String root : roots) {
+
+            // find root module
+            ModuleReference mref = findWithBeforeFinder(root);
+            if (mref == null) {
+
+                if (findInParent(root) != null) {
+                    // in parent, nothing to do
+                    continue;
+                }
+
+                mref = findWithAfterFinder(root);
+                if (mref == null) {
+                    findFail("Module %s not found", root);
+                }
+            }
+
+            if (isTracing()) {
+                trace("root %s", nameAndInfo(mref));
+            }
+
+            addFoundModule(mref);
+            q.push(mref.descriptor());
+        }
+
+        resolve(q);
+
+        return this;
+    }
+
+    /**
+     * Resolve all modules in the given queue. On completion the queue will be
+     * empty and any resolved modules will be added to {@code nameToReference}.
+     *
+     * @return The set of module resolved by this invocation of resolve
+     */
+    private Set<ModuleDescriptor> resolve(Deque<ModuleDescriptor> q) {
+        Set<ModuleDescriptor> resolved = new HashSet<>();
+
+        while (!q.isEmpty()) {
+            ModuleDescriptor descriptor = q.poll();
+            assert nameToReference.containsKey(descriptor.name());
+
+            // if the module is an automatic module then all automatic
+            // modules need to be resolved
+            if (descriptor.isAutomatic() && !haveAllAutomaticModules) {
+                addFoundAutomaticModules().forEach(mref -> {
+                    ModuleDescriptor other = mref.descriptor();
+                    q.offer(other);
+                    if (isTracing()) {
+                        trace("%s requires %s", descriptor.name(), nameAndInfo(mref));
+                    }
+                });
+                haveAllAutomaticModules = true;
+            }
+
+            // process dependences
+            for (ModuleDescriptor.Requires requires : descriptor.requires()) {
+
+                // only required at compile-time
+                if (requires.modifiers().contains(Modifier.STATIC))
+                    continue;
+
+                String dn = requires.name();
+
+                // find dependence
+                ModuleReference mref = findWithBeforeFinder(dn);
+                if (mref == null) {
+
+                    if (findInParent(dn) != null) {
+                        // dependence is in parent
+                        continue;
+                    }
+
+                    mref = findWithAfterFinder(dn);
+                    if (mref == null) {
+                        findFail("Module %s not found, required by %s",
+                                 dn, descriptor.name());
+                    }
+                }
+
+                if (isTracing() && !dn.equals("java.base")) {
+                    trace("%s requires %s", descriptor.name(), nameAndInfo(mref));
+                }
+
+                if (!nameToReference.containsKey(dn)) {
+                    addFoundModule(mref);
+                    q.offer(mref.descriptor());
+                }
+
+            }
+
+            resolved.add(descriptor);
+        }
+
+        return resolved;
+    }
+
+    /**
+     * Augments the set of resolved modules with modules induced by the
+     * service-use relation.
+     */
+    Resolver bind() {
+
+        // Scan the finders for all available service provider modules. As
+        // java.base uses services then then module finders will be scanned
+        // anyway.
+        Map<String, Set<ModuleReference>> availableProviders = new HashMap<>();
+        for (ModuleReference mref : findAll()) {
+            ModuleDescriptor descriptor = mref.descriptor();
+            if (!descriptor.provides().isEmpty()) {
+
+                for (Provides provides :  descriptor.provides()) {
+                    String sn = provides.service();
+
+                    // computeIfAbsent
+                    Set<ModuleReference> providers = availableProviders.get(sn);
+                    if (providers == null) {
+                        providers = new HashSet<>();
+                        availableProviders.put(sn, providers);
+                    }
+                    providers.add(mref);
+                }
+
+            }
+        }
+
+        // create the visit stack
+        Deque<ModuleDescriptor> q = new ArrayDeque<>();
+
+        // the initial set of modules that may use services
+        Set<ModuleDescriptor> initialConsumers;
+        if (ModuleLayer.boot() == null) {
+            initialConsumers = new HashSet<>();
+        } else {
+            initialConsumers = parents.stream()
+                    .flatMap(Configuration::configurations)
+                    .distinct()
+                    .flatMap(c -> c.descriptors().stream())
+                    .collect(Collectors.toSet());
+        }
+        for (ModuleReference mref : nameToReference.values()) {
+            initialConsumers.add(mref.descriptor());
+        }
+
+        // Where there is a consumer of a service then resolve all modules
+        // that provide an implementation of that service
+        Set<ModuleDescriptor> candidateConsumers = initialConsumers;
+        do {
+            for (ModuleDescriptor descriptor : candidateConsumers) {
+                if (!descriptor.uses().isEmpty()) {
+
+                    // the modules that provide at least one service
+                    Set<ModuleDescriptor> modulesToBind = null;
+                    if (isTracing()) {
+                        modulesToBind = new HashSet<>();
+                    }
+
+                    for (String service : descriptor.uses()) {
+                        Set<ModuleReference> mrefs = availableProviders.get(service);
+                        if (mrefs != null) {
+                            for (ModuleReference mref : mrefs) {
+                                ModuleDescriptor provider = mref.descriptor();
+                                if (!provider.equals(descriptor)) {
+
+                                    if (isTracing() && modulesToBind.add(provider)) {
+                                        trace("%s binds %s", descriptor.name(),
+                                                nameAndInfo(mref));
+                                    }
+
+                                    String pn = provider.name();
+                                    if (!nameToReference.containsKey(pn)) {
+                                        addFoundModule(mref);
+                                        q.push(provider);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            candidateConsumers = resolve(q);
+        } while (!candidateConsumers.isEmpty());
+
+        return this;
+    }
+
+    /**
+     * Add all automatic modules that have not already been found to the
+     * nameToReference map.
+     */
+    private Set<ModuleReference> addFoundAutomaticModules() {
+        Set<ModuleReference> result = new HashSet<>();
+        findAll().forEach(mref -> {
+            String mn = mref.descriptor().name();
+            if (mref.descriptor().isAutomatic() && !nameToReference.containsKey(mn)) {
+                addFoundModule(mref);
+                result.add(mref);
+            }
+        });
+        return result;
+    }
+
+    /**
+     * Add the module to the nameToReference map. Also check any constraints on
+     * the target platform with the constraints of other modules.
+     */
+    private void addFoundModule(ModuleReference mref) {
+        String mn = mref.descriptor().name();
+
+        if (mref instanceof ModuleReferenceImpl) {
+            ModuleTarget target = ((ModuleReferenceImpl)mref).moduleTarget();
+            if (target != null)
+                checkTargetPlatform(mn, target);
+        }
+
+        nameToReference.put(mn, mref);
+    }
+
+    /**
+     * Check that the module's constraints on the target platform does
+     * conflict with the constraint of other modules resolved so far.
+     */
+    private void checkTargetPlatform(String mn, ModuleTarget target) {
+        String value = target.targetPlatform();
+        if (value != null) {
+            if (targetPlatform == null) {
+                targetPlatform = value;
+            } else {
+                if (!value.equals(targetPlatform)) {
+                    findFail("Module %s has constraints on target platform (%s)"
+                             + " that conflict with other modules: %s", mn,
+                             value, targetPlatform);
+                }
+            }
+        }
+    }
+
+    /**
+     * Execute post-resolution checks and returns the module graph of resolved
+     * modules as a map.
+     */
+    Map<ResolvedModule, Set<ResolvedModule>> finish(Configuration cf) {
+        detectCycles();
+        checkHashes();
+        Map<ResolvedModule, Set<ResolvedModule>> graph = makeGraph(cf);
+        checkExportSuppliers(graph);
+        return graph;
+    }
+
+    /**
+     * Checks the given module graph for cycles.
+     *
+     * For now the implementation is a simple depth first search on the
+     * dependency graph. We'll replace this later, maybe with Tarjan.
+     */
+    private void detectCycles() {
+        visited = new HashSet<>();
+        visitPath = new LinkedHashSet<>(); // preserve insertion order
+        for (ModuleReference mref : nameToReference.values()) {
+            visit(mref.descriptor());
+        }
+        visited.clear();
+    }
+
+    // the modules that were visited
+    private Set<ModuleDescriptor> visited;
+
+    // the modules in the current visit path
+    private Set<ModuleDescriptor> visitPath;
+
+    private void visit(ModuleDescriptor descriptor) {
+        if (!visited.contains(descriptor)) {
+            boolean added = visitPath.add(descriptor);
+            if (!added) {
+                resolveFail("Cycle detected: %s", cycleAsString(descriptor));
+            }
+            for (ModuleDescriptor.Requires requires : descriptor.requires()) {
+                String dn = requires.name();
+
+                ModuleReference mref = nameToReference.get(dn);
+                if (mref != null) {
+                    ModuleDescriptor other = mref.descriptor();
+                    if (other != descriptor) {
+                        // dependency is in this configuration
+                        visit(other);
+                    }
+                }
+            }
+            visitPath.remove(descriptor);
+            visited.add(descriptor);
+        }
+    }
+
+    /**
+     * Returns a String with a list of the modules in a detected cycle.
+     */
+    private String cycleAsString(ModuleDescriptor descriptor) {
+        List<ModuleDescriptor> list = new ArrayList<>(visitPath);
+        list.add(descriptor);
+        int index = list.indexOf(descriptor);
+        return list.stream()
+                .skip(index)
+                .map(ModuleDescriptor::name)
+                .collect(Collectors.joining(" -> "));
+    }
+
+
+    /**
+     * Checks the hashes in the module descriptor to ensure that they match
+     * any recorded hashes.
+     */
+    private void checkHashes() {
+        for (ModuleReference mref : nameToReference.values()) {
+
+            // get the recorded hashes, if any
+            if (!(mref instanceof ModuleReferenceImpl))
+                continue;
+            ModuleHashes hashes = ((ModuleReferenceImpl)mref).recordedHashes();
+            if (hashes == null)
+                continue;
+
+            ModuleDescriptor descriptor = mref.descriptor();
+            String algorithm = hashes.algorithm();
+            for (String dn : hashes.names()) {
+                ModuleReference mref2 = nameToReference.get(dn);
+                if (mref2 == null) {
+                    ResolvedModule resolvedModule = findInParent(dn);
+                    if (resolvedModule != null)
+                        mref2 = resolvedModule.reference();
+                }
+                if (mref2 == null)
+                    continue;
+
+                if (!(mref2 instanceof ModuleReferenceImpl)) {
+                    findFail("Unable to compute the hash of module %s", dn);
+                }
+
+                ModuleReferenceImpl other = (ModuleReferenceImpl)mref2;
+                if (other != null) {
+                    byte[] recordedHash = hashes.hashFor(dn);
+                    byte[] actualHash = other.computeHash(algorithm);
+                    if (actualHash == null)
+                        findFail("Unable to compute the hash of module %s", dn);
+                    if (!Arrays.equals(recordedHash, actualHash)) {
+                        findFail("Hash of %s (%s) differs to expected hash (%s)" +
+                                 " recorded in %s", dn, toHexString(actualHash),
+                                 toHexString(recordedHash), descriptor.name());
+                    }
+                }
+            }
+
+        }
+    }
+
+    private static String toHexString(byte[] ba) {
+        StringBuilder sb = new StringBuilder(ba.length * 2);
+        for (byte b: ba) {
+            sb.append(String.format("%02x", b & 0xff));
+        }
+        return sb.toString();
+    }
+
+
+    /**
+     * Computes the readability graph for the modules in the given Configuration.
+     *
+     * The readability graph is created by propagating "requires" through the
+     * "requires transitive" edges of the module dependence graph. So if the
+     * module dependence graph has m1 requires m2 && m2 requires transitive m3
+     * then the resulting readability graph will contain m1 reads m2, m1 reads m3,
+     * and m2 reads m3.
+     */
+    private Map<ResolvedModule, Set<ResolvedModule>> makeGraph(Configuration cf) {
+
+        // initial capacity of maps to avoid resizing
+        int capacity = 1 + (4 * nameToReference.size())/ 3;
+
+        // the "reads" graph starts as a module dependence graph and
+        // is iteratively updated to be the readability graph
+        Map<ResolvedModule, Set<ResolvedModule>> g1 = new HashMap<>(capacity);
+
+        // the "requires transitive" graph, contains requires transitive edges only
+        Map<ResolvedModule, Set<ResolvedModule>> g2;
+
+        // need "requires transitive" from the modules in parent configurations
+        // as there may be selected modules that have a dependency on modules in
+        // the parent configuration.
+        if (ModuleLayer.boot() == null) {
+            g2 = new HashMap<>(capacity);
+        } else {
+            g2 = parents.stream()
+                .flatMap(Configuration::configurations)
+                .distinct()
+                .flatMap(c ->
+                    c.modules().stream().flatMap(m1 ->
+                        m1.descriptor().requires().stream()
+                            .filter(r -> r.modifiers().contains(Modifier.TRANSITIVE))
+                            .flatMap(r -> {
+                                Optional<ResolvedModule> m2 = c.findModule(r.name());
+                                assert m2.isPresent()
+                                        || r.modifiers().contains(Modifier.STATIC);
+                                return m2.stream();
+                            })
+                            .map(m2 -> Map.entry(m1, m2))
+                    )
+                )
+                // stream of m1->m2
+                .collect(Collectors.groupingBy(Map.Entry::getKey,
+                        HashMap::new,
+                        Collectors.mapping(Map.Entry::getValue, Collectors.toSet())
+            ));
+        }
+
+        // populate g1 and g2 with the dependences from the selected modules
+
+        Map<String, ResolvedModule> nameToResolved = new HashMap<>(capacity);
+
+        for (ModuleReference mref : nameToReference.values()) {
+            ModuleDescriptor descriptor = mref.descriptor();
+            String name = descriptor.name();
+
+            ResolvedModule m1 = computeIfAbsent(nameToResolved, name, cf, mref);
+
+            Set<ResolvedModule> reads = new HashSet<>();
+            Set<ResolvedModule> requiresTransitive = new HashSet<>();
+
+            for (ModuleDescriptor.Requires requires : descriptor.requires()) {
+                String dn = requires.name();
+
+                ResolvedModule m2 = null;
+                ModuleReference mref2 = nameToReference.get(dn);
+                if (mref2 != null) {
+                    // same configuration
+                    m2 = computeIfAbsent(nameToResolved, dn, cf, mref2);
+                } else {
+                    // parent configuration
+                    m2 = findInParent(dn);
+                    if (m2 == null) {
+                        assert requires.modifiers().contains(Modifier.STATIC);
+                        continue;
+                    }
+                }
+
+                // m1 requires m2 => m1 reads m2
+                reads.add(m2);
+
+                // m1 requires transitive m2
+                if (requires.modifiers().contains(Modifier.TRANSITIVE)) {
+                    requiresTransitive.add(m2);
+                }
+
+            }
+
+            // automatic modules read all selected modules and all modules
+            // in parent configurations
+            if (descriptor.isAutomatic()) {
+
+                // reads all selected modules
+                // `requires transitive` all selected automatic modules
+                for (ModuleReference mref2 : nameToReference.values()) {
+                    ModuleDescriptor descriptor2 = mref2.descriptor();
+                    String name2 = descriptor2.name();
+
+                    if (!name.equals(name2)) {
+                        ResolvedModule m2
+                            = computeIfAbsent(nameToResolved, name2, cf, mref2);
+                        reads.add(m2);
+                        if (descriptor2.isAutomatic())
+                            requiresTransitive.add(m2);
+                    }
+                }
+
+                // reads all modules in parent configurations
+                // `requires transitive` all automatic modules in parent
+                // configurations
+                for (Configuration parent : parents) {
+                    parent.configurations()
+                            .map(Configuration::modules)
+                            .flatMap(Set::stream)
+                            .forEach(m -> {
+                                reads.add(m);
+                                if (m.reference().descriptor().isAutomatic())
+                                    requiresTransitive.add(m);
+                            });
+                }
+            }
+
+            g1.put(m1, reads);
+            g2.put(m1, requiresTransitive);
+        }
+
+        // Iteratively update g1 until there are no more requires transitive
+        // to propagate
+        boolean changed;
+        List<ResolvedModule> toAdd = new ArrayList<>();
+        do {
+            changed = false;
+            for (Set<ResolvedModule> m1Reads : g1.values()) {
+                for (ResolvedModule m2 : m1Reads) {
+                    Set<ResolvedModule> m2RequiresTransitive = g2.get(m2);
+                    if (m2RequiresTransitive != null) {
+                        for (ResolvedModule m3 : m2RequiresTransitive) {
+                            if (!m1Reads.contains(m3)) {
+                                // m1 reads m2, m2 requires transitive m3
+                                // => need to add m1 reads m3
+                                toAdd.add(m3);
+                            }
+                        }
+                    }
+                }
+                if (!toAdd.isEmpty()) {
+                    m1Reads.addAll(toAdd);
+                    toAdd.clear();
+                    changed = true;
+                }
+            }
+        } while (changed);
+
+        return g1;
+    }
+
+    /**
+     * Equivalent to
+     * <pre>{@code
+     *     map.computeIfAbsent(name, k -> new ResolvedModule(cf, mref))
+     * </pre>}
+     */
+    private ResolvedModule computeIfAbsent(Map<String, ResolvedModule> map,
+                                           String name,
+                                           Configuration cf,
+                                           ModuleReference mref)
+    {
+        ResolvedModule m = map.get(name);
+        if (m == null) {
+            m = new ResolvedModule(cf, mref);
+            map.put(name, m);
+        }
+        return m;
+    }
+
+
+    /**
+     * Checks the readability graph to ensure that
+     * <ol>
+     *   <li><p> A module does not read two or more modules with the same name.
+     *   This includes the case where a module reads another another with the
+     *   same name as itself. </p></li>
+     *   <li><p> Two or more modules in the configuration don't export the same
+     *   package to a module that reads both. This includes the case where a
+     *   module {@code M} containing package {@code p} reads another module
+     *   that exports {@code p} to {@code M}. </p></li>
+     *   <li><p> A module {@code M} doesn't declare that it "{@code uses p.S}"
+     *   or "{@code provides p.S with ...}" but package {@code p} is neither
+     *   in module {@code M} nor exported to {@code M} by any module that
+     *   {@code M} reads. </p></li>
+     * </ol>
+     */
+    private void checkExportSuppliers(Map<ResolvedModule, Set<ResolvedModule>> graph) {
+
+        for (Map.Entry<ResolvedModule, Set<ResolvedModule>> e : graph.entrySet()) {
+            ModuleDescriptor descriptor1 = e.getKey().descriptor();
+            String name1 = descriptor1.name();
+
+            // the names of the modules that are read (including self)
+            Set<String> names = new HashSet<>();
+            names.add(name1);
+
+            // the map of packages that are local or exported to descriptor1
+            Map<String, ModuleDescriptor> packageToExporter = new HashMap<>();
+
+            // local packages
+            Set<String> packages = descriptor1.packages();
+            for (String pn : packages) {
+                packageToExporter.put(pn, descriptor1);
+            }
+
+            // descriptor1 reads descriptor2
+            Set<ResolvedModule> reads = e.getValue();
+            for (ResolvedModule endpoint : reads) {
+                ModuleDescriptor descriptor2 = endpoint.descriptor();
+
+                String name2 = descriptor2.name();
+                if (descriptor2 != descriptor1 && !names.add(name2)) {
+                    if (name2.equals(name1)) {
+                        resolveFail("Module %s reads another module named %s",
+                                    name1, name1);
+                    } else{
+                        resolveFail("Module %s reads more than one module named %s",
+                                     name1, name2);
+                    }
+                }
+
+                if (descriptor2.isAutomatic()) {
+                    // automatic modules read self and export all packages
+                    if (descriptor2 != descriptor1) {
+                        for (String source : descriptor2.packages()) {
+                            ModuleDescriptor supplier
+                                = packageToExporter.putIfAbsent(source, descriptor2);
+
+                            // descriptor2 and 'supplier' export source to descriptor1
+                            if (supplier != null) {
+                                failTwoSuppliers(descriptor1, source, descriptor2, supplier);
+                            }
+                        }
+
+                    }
+                } else {
+                    for (ModuleDescriptor.Exports export : descriptor2.exports()) {
+                        if (export.isQualified()) {
+                            if (!export.targets().contains(descriptor1.name()))
+                                continue;
+                        }
+
+                        // source is exported by descriptor2
+                        String source = export.source();
+                        ModuleDescriptor supplier
+                            = packageToExporter.putIfAbsent(source, descriptor2);
+
+                        // descriptor2 and 'supplier' export source to descriptor1
+                        if (supplier != null) {
+                            failTwoSuppliers(descriptor1, source, descriptor2, supplier);
+                        }
+                    }
+
+                }
+            }
+
+            // uses/provides checks not applicable to automatic modules
+            if (!descriptor1.isAutomatic()) {
+
+                // uses S
+                for (String service : descriptor1.uses()) {
+                    String pn = packageName(service);
+                    if (!packageToExporter.containsKey(pn)) {
+                        resolveFail("Module %s does not read a module that exports %s",
+                                    descriptor1.name(), pn);
+                    }
+                }
+
+                // provides S
+                for (ModuleDescriptor.Provides provides : descriptor1.provides()) {
+                    String pn = packageName(provides.service());
+                    if (!packageToExporter.containsKey(pn)) {
+                        resolveFail("Module %s does not read a module that exports %s",
+                                    descriptor1.name(), pn);
+                    }
+                }
+
+            }
+
+        }
+
+    }
+
+    /**
+     * Fail because a module in the configuration exports the same package to
+     * a module that reads both. This includes the case where a module M
+     * containing a package p reads another module that exports p to at least
+     * module M.
+     */
+    private void failTwoSuppliers(ModuleDescriptor descriptor,
+                                  String source,
+                                  ModuleDescriptor supplier1,
+                                  ModuleDescriptor supplier2) {
+
+        if (supplier2 == descriptor) {
+            ModuleDescriptor tmp = supplier1;
+            supplier1 = supplier2;
+            supplier2 = tmp;
+        }
+
+        if (supplier1 == descriptor) {
+            resolveFail("Module %s contains package %s"
+                         + ", module %s exports package %s to %s",
+                    descriptor.name(),
+                    source,
+                    supplier2.name(),
+                    source,
+                    descriptor.name());
+        } else {
+            resolveFail("Modules %s and %s export package %s to module %s",
+                    supplier1.name(),
+                    supplier2.name(),
+                    source,
+                    descriptor.name());
+        }
+
+    }
+
+
+    /**
+     * Find a module of the given name in the parent configurations
+     */
+    private ResolvedModule findInParent(String mn) {
+        for (Configuration parent : parents) {
+            Optional<ResolvedModule> om = parent.findModule(mn);
+            if (om.isPresent())
+                return om.get();
+        }
+        return null;
+    }
+
+
+    /**
+     * Invokes the beforeFinder to find method to find the given module.
+     */
+    private ModuleReference findWithBeforeFinder(String mn) {
+
+        return beforeFinder.find(mn).orElse(null);
+
+    }
+
+    /**
+     * Invokes the afterFinder to find method to find the given module.
+     */
+    private ModuleReference findWithAfterFinder(String mn) {
+        return afterFinder.find(mn).orElse(null);
+    }
+
+    /**
+     * Returns the set of all modules that are observable with the before
+     * and after ModuleFinders.
+     */
+    private Set<ModuleReference> findAll() {
+        Set<ModuleReference> beforeModules = beforeFinder.findAll();
+        Set<ModuleReference> afterModules = afterFinder.findAll();
+
+        if (afterModules.isEmpty())
+            return beforeModules;
+
+        if (beforeModules.isEmpty()
+                && parents.size() == 1
+                && parents.get(0) == Configuration.empty())
+            return afterModules;
+
+        Set<ModuleReference> result = new HashSet<>(beforeModules);
+        for (ModuleReference mref : afterModules) {
+            String name = mref.descriptor().name();
+            if (!beforeFinder.find(name).isPresent()
+                    && findInParent(name) == null) {
+                result.add(mref);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Returns the package name
+     */
+    private static String packageName(String cn) {
+        int index = cn.lastIndexOf(".");
+        return (index == -1) ? "" : cn.substring(0, index);
+    }
+
+    /**
+     * Throw FindException with the given format string and arguments
+     */
+    private static void findFail(String fmt, Object ... args) {
+        String msg = String.format(fmt, args);
+        throw new FindException(msg);
+    }
+
+    /**
+     * Throw ResolutionException with the given format string and arguments
+     */
+    private static void resolveFail(String fmt, Object ... args) {
+        String msg = String.format(fmt, args);
+        throw new ResolutionException(msg);
+    }
+
+    /**
+     * Tracing support
+     */
+
+    private boolean isTracing() {
+        return traceOutput != null;
+    }
+
+    private void trace(String fmt, Object ... args) {
+        if (traceOutput != null) {
+            traceOutput.format(fmt, args);
+            traceOutput.println();
+        }
+    }
+
+    private String nameAndInfo(ModuleReference mref) {
+        ModuleDescriptor descriptor = mref.descriptor();
+        StringBuilder sb = new StringBuilder(descriptor.name());
+        mref.location().ifPresent(uri -> sb.append(" " + uri));
+        if (descriptor.isAutomatic())
+            sb.append(" automatic");
+        return sb.toString();
+    }
+}