test/jdk/modules/etc/JdkQualifiedExportTest.java

@@ -33,10 +33,11 @@
 import jdk.internal.module.ModuleInfo;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UncheckedIOException;
+import java.lang.module.Configuration;
 import java.lang.module.ModuleDescriptor;
 import java.lang.module.ModuleDescriptor.Exports;
 import java.lang.module.ModuleDescriptor.Opens;
 import java.lang.module.ModuleFinder;
 import java.lang.module.ModuleReference;

@@ -67,23 +68,21 @@
         checkOpens(md);
     }
 
     static Set<String> KNOWN_EXCEPTIONS =
         Set.of("java.xml/com.sun.xml.internal.stream.writers",
+               "jdk.internal.vm.ci/jdk.vm.ci.services",
                "jdk.jsobject/jdk.internal.netscape.javascript.spi");
-    static Set<String> DEPLOY_MODULES =
-        Set.of("jdk.deploy", "jdk.plugin", "jdk.javaws");
 
     static void checkExports(ModuleDescriptor md) {
         // build a map of upgradeable module to Exports that are qualified to it
         // skip the qualified exports
         Map<String, Set<Exports>> targetToExports = new HashMap<>();
         md.exports().stream()
           .filter(Exports::isQualified)
           .forEach(e -> e.targets().stream()
-                         .filter(mn -> !HashedModules.contains(mn) &&
-                                           ModuleFinder.ofSystem().find(mn).isPresent())
+                         .filter(mn -> accept(md, mn))
                          .forEach(t -> targetToExports.computeIfAbsent(t, _k -> new HashSet<>())
                                                       .add(e)));
 
         if (targetToExports.size() > 0) {
             String mn = md.name();

@@ -95,14 +94,13 @@
                     e.getValue().stream()
                      .forEach(exp -> System.err.format("    exports %s to %s%n",
                                                        exp.source(), e.getKey()));
                 });
 
-            // workaround until all qualified exports to upgradeable modules
-            // are eliminated
+            // no qualified exports to upgradeable modules are expected
+            // except the known exception cases
             if (targetToExports.entrySet().stream()
-                    .filter(e -> !DEPLOY_MODULES.contains(e.getKey()))
                     .flatMap(e -> e.getValue().stream())
                     .anyMatch(e -> !KNOWN_EXCEPTIONS.contains(mn + "/" + e.source()))) {
                 throw new RuntimeException(mn + " can't export package to upgradeable modules");
             }
         }

@@ -113,12 +111,11 @@
         // skip the qualified exports
         Map<String, Set<Opens>> targetToOpens = new HashMap<>();
         md.opens().stream()
             .filter(Opens::isQualified)
             .forEach(e -> e.targets().stream()
-                           .filter(mn -> !HashedModules.contains(mn) &&
-                                            ModuleFinder.ofSystem().find(mn).isPresent())
+                           .filter(mn -> accept(md, mn))
                            .forEach(t -> targetToOpens.computeIfAbsent(t, _k -> new HashSet<>())
                                                       .add(e)));
 
         if (targetToOpens.size() > 0) {
             String mn = md.name();

@@ -134,10 +131,27 @@
 
             throw new RuntimeException(mn + " can't open package to upgradeable modules");
         }
     }
 
+    /**
+     * Returns true if target is an upgradeable module but not required
+     * by the source module directly and indirectly.
+     */
+    private static boolean accept(ModuleDescriptor source, String target) {
+        if (HashedModules.contains(target))
+            return false;
+
+        if (!ModuleFinder.ofSystem().find(target).isPresent())
+            return false;
+
+        Configuration cf = Configuration.empty().resolve(ModuleFinder.of(),
+                                                         ModuleFinder.ofSystem(),
+                                                         Set.of(source.name()));
+        return cf.findModule(target).orElse(null) == null;
+    }
+
     private static class HashedModules {
         static Set<String> HASHED_MODULES = hashedModules();
 
         static Set<String> hashedModules() {
             Module javaBase = Object.class.getModule();