test/jdk/modules/etc/JdkQualifiedExportTest.java

*** 33,42 ****
--- 33,43 ----
  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,89 ****
          checkOpens(md);
      }
  
      static Set<String> KNOWN_EXCEPTIONS =
          Set.of("java.xml/com.sun.xml.internal.stream.writers",
                 "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())
                           .forEach(t -> targetToExports.computeIfAbsent(t, _k -> new HashSet<>())
                                                        .add(e)));
  
          if (targetToExports.size() > 0) {
              String mn = md.name();
--- 68,88 ----
          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 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 -> accept(md, mn))
                           .forEach(t -> targetToExports.computeIfAbsent(t, _k -> new HashSet<>())
                                                        .add(e)));
  
          if (targetToExports.size() > 0) {
              String mn = md.name();
*** 95,108 ****
                      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
              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");
              }
          }
--- 94,106 ----
                      e.getValue().stream()
                       .forEach(exp -> System.err.format("    exports %s to %s%n",
                                                         exp.source(), e.getKey()));
                  });
  
!             // no qualified exports to upgradeable modules are expected
!             // except the known exception cases
              if (targetToExports.entrySet().stream()
                      .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,124 ****
          // 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())
                             .forEach(t -> targetToOpens.computeIfAbsent(t, _k -> new HashSet<>())
                                                        .add(e)));
  
          if (targetToOpens.size() > 0) {
              String mn = md.name();
--- 111,121 ----
          // skip the qualified exports
          Map<String, Set<Opens>> targetToOpens = new HashMap<>();
          md.opens().stream()
              .filter(Opens::isQualified)
              .forEach(e -> e.targets().stream()
!                            .filter(mn -> accept(md, mn))
                             .forEach(t -> targetToOpens.computeIfAbsent(t, _k -> new HashSet<>())
                                                        .add(e)));
  
          if (targetToOpens.size() > 0) {
              String mn = md.name();
*** 134,143 ****
--- 131,157 ----
  
              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();