jdk-sandbox: comparison jdk/src/java.base/share/classes/java/lang/module/Resolver.java

equal deleted inserted replaced

-:7a4a59859ac0
+:a60f280f803c
 */
 package java.lang.module;
 import java.io.PrintStream;
+import java.lang.module.ModuleDescriptor.Provides;
 import java.lang.module.ModuleDescriptor.Requires.Modifier;
+import java.lang.reflect.Layer;
 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 jdk.internal.module.ModuleHashes;
 /**
 * The resolver used by {@link Configuration#resolveRequires} and
 * {@link Configuration#resolveRequiresAndUses}.
+*
+* @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 Configuration parent;
+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<>();
 Resolver(ModuleFinder beforeFinder,
-Configuration parent,
+List<Configuration> parents,
 ModuleFinder afterFinder,
 PrintStream traceOutput) {
 this.beforeFinder = beforeFinder;
-this.parent = parent;
+this.parents = parents;
 this.afterFinder = afterFinder;
 this.traceOutput = traceOutput;
 }
 for (String root : roots) {
 // find root module
 ModuleReference mref = findWithBeforeFinder(root);
 if (mref == null) {
-if (parent.findModule(root).isPresent()) {
+if (findInParent(root) != null) {
 // in parent, nothing to do
 continue;
 }
 mref = findWithAfterFinder(root);
 if (mref == null) {
 fail("Module %s not found", root);
 }
 }
 ModuleDescriptor descriptor = q.poll();
 assert nameToReference.containsKey(descriptor.name());
 // 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 (parent.findModule(dn).isPresent())
+if (findInParent(dn) != null) {
+// dependence is in parent
 continue;
+}
 mref = findWithAfterFinder(dn);
 if (mref == null) {
 fail("Module %s not found, required by %s",
 dn, descriptor.name());
 Map<String, Set<ModuleReference>> availableProviders = new HashMap<>();
 for (ModuleReference mref : findAll()) {
 ModuleDescriptor descriptor = mref.descriptor();
 if (!descriptor.provides().isEmpty()) {
-for (String sn : descriptor.provides().keySet()) {
+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);
 // create the visit stack
 Deque<ModuleDescriptor> q = new ArrayDeque<>();
 // the initial set of modules that may use services
-Set<ModuleDescriptor> candidateConsumers = new HashSet<>();
+Set<ModuleDescriptor> initialConsumers;
-Configuration p = parent;
+if (Layer.boot() == null) {
-while (p != null) {
+initialConsumers = new HashSet<>();
-candidateConsumers.addAll(p.descriptors());
+} else {
-p = p.parent().orElse(null);
+initialConsumers = parents.stream()
+.flatMap(Configuration::configurations)
+.distinct()
+.flatMap(c -> c.descriptors().stream())
+.collect(Collectors.toSet());
 }
 for (ModuleReference mref : nameToReference.values()) {
-candidateConsumers.add(mref.descriptor());
+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()) {
 for (String service : descriptor.uses()) {
 Set<ModuleReference> mrefs = availableProviders.get(service);
 }
 }
 }
 candidateConsumers = resolve(q);
 } while (!candidateConsumers.isEmpty());
 return this;
 }
 String algorithm = hashes.algorithm();
 for (String dn : hashes.names()) {
 ModuleReference other = nameToReference.get(dn);
 if (other == null) {
-other = parent.findModule(dn)
+ResolvedModule resolvedModule = findInParent(dn);
-.map(ResolvedModule::reference)
+if (resolvedModule != null)
-.orElse(null);
+other = resolvedModule.reference();
 }
 // skip checking the hash if the module has been patched
 if (other != null && !other.isPatched()) {
-String recordedHash = hashes.hashFor(dn);
+byte[] recordedHash = hashes.hashFor(dn);
-String actualHash = other.computeHash(algorithm);
+byte[] actualHash = other.computeHash(algorithm);
 if (actualHash == null)
 fail("Unable to compute the hash of module %s", dn);
-if (!recordedHash.equals(actualHash)) {
+if (!Arrays.equals(recordedHash, actualHash)) {
 fail("Hash of %s (%s) differs to expected hash (%s)" +
-" recorded in %s", dn, actualHash, recordedHash,
+" recorded in %s", dn, toHexString(actualHash),
-descriptor.name());
+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
-* "public requires" edges of the module dependence graph. So if the module
+* "requires transitive" edges of the module dependence graph. So if the
-* dependence graph has m1 requires m2 && m2 requires public m3 then the
+* module dependence graph has m1 requires m2 && m2 requires transitive m3
-* resulting readability graph will contain m1 reads m2, m1 reads m3, and
+* then the resulting readability graph will contain m1 reads m2, m1 reads m3,
-* m2 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<>();
+Map<ResolvedModule, Set<ResolvedModule>> g1 = new HashMap<>(capacity);
-// the "requires public" graph, contains requires public edges only
+// the "requires transitive" graph, contains requires transitive edges only
-Map<ResolvedModule, Set<ResolvedModule>> g2 = new HashMap<>();
+Map<ResolvedModule, Set<ResolvedModule>> g2;
+// need "requires transitive" from the modules in parent configurations
-// need "requires public" from the modules in parent configurations as
+// as there may be selected modules that have a dependency on modules in
-// there may be selected modules that have a dependency on modules in
 // the parent configuration.
+if (Layer.boot() == null) {
-Configuration p = parent;
+g2 = new HashMap<>(capacity);
-while (p != null) {
+} else {
-for (ModuleDescriptor descriptor : p.descriptors()) {
+g2 = parents.stream()
-String name = descriptor.name();
+.flatMap(Configuration::configurations)
-ResolvedModule m1 = p.findModule(name)
+.distinct()
-.orElseThrow(() -> new InternalError(name + " not found"));
+.flatMap(c ->
-for (ModuleDescriptor.Requires requires : descriptor.requires()) {
+c.modules().stream().flatMap(m1 ->
-if (requires.modifiers().contains(Modifier.PUBLIC)) {
+m1.descriptor().requires().stream()
-String dn = requires.name();
+.filter(r -> r.modifiers().contains(Modifier.TRANSITIVE))
-ResolvedModule m2 = p.findModule(dn)
+.flatMap(r -> {
-.orElseThrow(() -> new InternalError(dn + " not found"));
+Optional<ResolvedModule> m2 = c.findModule(r.name());
-g2.computeIfAbsent(m1, k -> new HashSet<>()).add(m2);
+assert m2.isPresent()
-}
+|| r.modifiers().contains(Modifier.STATIC);
-}
+return m2.stream();
-}
+})
+.map(m2 -> Map.entry(m1, m2))
-p = p.parent().orElse(null);
+)
+)
+// 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<>();
+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> requiresPublic = new HashSet<>();
+Set<ResolvedModule> requiresTransitive = new HashSet<>();
 for (ModuleDescriptor.Requires requires : descriptor.requires()) {
 String dn = requires.name();
-ResolvedModule m2;
+ResolvedModule m2 = null;
 ModuleReference mref2 = nameToReference.get(dn);
 if (mref2 != null) {
 // same configuration
 m2 = computeIfAbsent(nameToResolved, dn, cf, mref2);
 } else {
 // parent configuration
-m2 = parent.findModule(dn).orElse(null);
+m2 = findInParent(dn);
 if (m2 == null) {
+assert requires.modifiers().contains(Modifier.STATIC);
 continue;
 }
 }
 // m1 requires m2 => m1 reads m2
 reads.add(m2);
-// m1 requires public m2
+// m1 requires transitive m2
-if (requires.modifiers().contains(Modifier.PUBLIC)) {
+if (requires.modifiers().contains(Modifier.TRANSITIVE)) {
-requiresPublic.add(m2);
+requiresTransitive.add(m2);
 }
 }
 // automatic modules read all selected modules and all modules
 // in parent configurations
 if (descriptor.isAutomatic()) {
 // reads all selected modules
-// `requires public` all selected automatic 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())
-requiresPublic.add(m2);
+requiresTransitive.add(m2);
 }
 }
 // reads all modules in parent configurations
-// `requires public` all automatic modules in parent configurations
+// `requires transitive` all automatic modules in parent
-p = parent;
+// configurations
-while (p != null) {
+for (Configuration parent : parents) {
-for (ResolvedModule m : p.modules()) {
+parent.configurations()
-reads.add(m);
+.map(Configuration::modules)
-if (m.reference().descriptor().isAutomatic())
+.flatMap(Set::stream)
-requiresPublic.add(m);
+.forEach(m -> {
-}
+reads.add(m);
-p = p.parent().orElse(null);
+if (m.reference().descriptor().isAutomatic())
-}
+requiresTransitive.add(m);
+});
+}
 }
 g1.put(m1, reads);
-g2.put(m1, requiresPublic);
+g2.put(m1, requiresTransitive);
 }
-// Iteratively update g1 until there are no more requires public to propagate
+// Iteratively update g1 until there are no more requires transitive
+// to propagate
 boolean changed;
-Set<ResolvedModule> toAdd = new HashSet<>();
+List<ResolvedModule> toAdd = new ArrayList<>();
 do {
 changed = false;
 for (Set<ResolvedModule> m1Reads : g1.values()) {
 for (ResolvedModule m2 : m1Reads) {
-Set<ResolvedModule> m2RequiresPublic = g2.get(m2);
+Set<ResolvedModule> m2RequiresTransitive = g2.get(m2);
-if (m2RequiresPublic != null) {
+if (m2RequiresTransitive != null) {
-for (ResolvedModule m3 : m2RequiresPublic) {
+for (ResolvedModule m3 : m2RequiresTransitive) {
 if (!m1Reads.contains(m3)) {
-// m1 reads m2, m2 requires public m3
+// m1 reads m2, m2 requires transitive m3
 // => need to add m1 reads m3
 toAdd.add(m3);
 }
 }
 }
 }
 // source is exported to descriptor2
 String source = export.source();
 ModuleDescriptor other
-= packageToExporter.put(source, descriptor2);
+= packageToExporter.putIfAbsent(source, descriptor2);
 if (other != null && other != descriptor2) {
 // package might be local to descriptor1
 if (other == descriptor1) {
 fail("Module %s contains package %s"
 descriptor1.name(), pn);
 }
 }
 // provides S
-for (Map.Entry<String, ModuleDescriptor.Provides> entry :
+for (ModuleDescriptor.Provides provides : descriptor1.provides()) {
-descriptor1.provides().entrySet()) {
+String pn = packageName(provides.service());
-String service = entry.getKey();
-ModuleDescriptor.Provides provides = entry.getValue();
-String pn = packageName(service);
 if (!packageToExporter.containsKey(pn)) {
 fail("Module %s does not read a module that exports %s",
 descriptor1.name(), pn);
 }
 }
 }
+}
+/**
+* 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.
 Set<ModuleReference> afterModules = afterFinder.findAll();
 if (afterModules.isEmpty())
 return beforeModules;
-if (beforeModules.isEmpty() && parent == Configuration.empty())
+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()
-&& !parent.findModule(name).isPresent())
+&& findInParent(name) == null) {
 result.add(mref);
+}
 }
 return result;
 } catch (FindException e) {

changeset 42338	a60f280f803c
parent 39050	9de41b79ec7e
child 42703	20c39ea4a507