archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 06:45:07 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8197532: Re-examine policy for the default set of modules when compiling or running code on the class path

Browse source 
Reviewed-by: jlahoda, mchung
This commit is contained in:
Alan Bateman 2018-06-23 08:03:52 +01:00
parent 6e0bd36f42
commit 7523687071
12 changed files with 363 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/java.base/share/classes/java/lang/module/package-info.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013, 2017, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2013, 2018, 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
@ -154,8 +154,9 @@
* application module specified to the 'java' launcher. When compiling code in
* the unnamed module, or at run-time when the main application class is loaded
* from the class path, then the default set of root modules is implementation
* specific (In the JDK implementation it is the module "java.se", if observable,
* and every observable module that exports an API). </p>
* specific. In the JDK the default set of root modules contains every module
* that is observable on the upgrade module path or among the system modules,
* and that exports at least one package without qualification. </p>
*
* <h2> Observable modules </h2>
*

74
src/java.base/share/classes/jdk/internal/module/DefaultRoots.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2017, 2018, 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
@ -22,13 +22,14 @@
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.internal.module;
import java.lang.module.ModuleDescriptor;
import java.lang.module.ModuleFinder;
import java.lang.module.ModuleReference;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
/**
* Defines methods to compute the default set of root modules for the unnamed
@ -36,58 +37,45 @@ import java.util.Set;
*/
public final class DefaultRoots {
private static final String JAVA_SE = "java.se";
private DefaultRoots() { }
/**
* Returns the default set of root modules for the unnamed module computed from
* the system modules observable with the given module finder.
* Returns the default set of root modules for the unnamed module from the
* modules observable with the intersection of two module finders.
*
* The first module finder should be the module finder that finds modules on
* the upgrade module path or among the system modules. The second module
* finder should be the module finder that finds all modules on the module
* path, or a subset of when using --limit-modules.
*/
static Set<String> compute(ModuleFinder systemModuleFinder, ModuleFinder finder) {
Set<String> roots = new HashSet<>();
boolean hasJava = false;
if (systemModuleFinder.find(JAVA_SE).isPresent()) {
if (finder == systemModuleFinder || finder.find(JAVA_SE).isPresent()) {
// java.se is a system module
hasJava = true;
roots.add(JAVA_SE);
}
}
for (ModuleReference mref : systemModuleFinder.findAll()) {
String mn = mref.descriptor().name();
if (hasJava && mn.startsWith("java.")) {
// not a root
continue;
}
if (ModuleResolution.doNotResolveByDefault(mref)) {
// not a root
continue;
}
if ((finder == systemModuleFinder || finder.find(mn).isPresent())) {
// add as root if exports at least one package to all modules
ModuleDescriptor descriptor = mref.descriptor();
for (ModuleDescriptor.Exports e : descriptor.exports()) {
if (!e.isQualified()) {
roots.add(mn);
break;
}
}
}
}
return roots;
static Set<String> compute(ModuleFinder finder1, ModuleFinder finder2) {
return finder1.findAll().stream()
.filter(mref -> !ModuleResolution.doNotResolveByDefault(mref))
.map(ModuleReference::descriptor)
.filter(descriptor -> finder2.find(descriptor.name()).isPresent()
&& exportsAPI(descriptor))
.map(ModuleDescriptor::name)
.collect(Collectors.toSet());
}
/**
* Returns the default set of root modules for the unnamed module from the
* modules observable with the given module finder.
*
* This method is used by the jlink system modules plugin.
*/
public static Set<String> compute(ModuleFinder finder) {
return compute(finder, finder);
}
/**
* Returns true if the given module exports a package to all modules
*/
private static boolean exportsAPI(ModuleDescriptor descriptor) {
return descriptor.exports()
.stream()
.filter(e -> !e.isQualified())
.findAny()
.isPresent();
}
}

9
src/java.base/share/classes/jdk/internal/module/ModuleBootstrap.java
View file

@ -280,11 +280,10 @@ public final class ModuleBootstrap {
// If there is no initial module specified then assume that the initial
// module is the unnamed module of the application class loader. This
// is implemented by resolving "java.se" and all (non-java.*) modules
// that export an API. If "java.se" is not observable then all java.*
// modules are resolved. Modules that have the DO_NOT_RESOLVE_BY_DEFAULT
// bit set in their ModuleResolution attribute flags are excluded from
// the default set of roots.
// is implemented by resolving all observable modules that export an
// API. Modules that have the DO_NOT_RESOLVE_BY_DEFAULT bit set in
// their ModuleResolution attribute flags are excluded from the
// default set of roots.
if (mainModule == null || addAllDefaultModules) {
roots.addAll(DefaultRoots.compute(systemModuleFinder, finder));
}