jdk-sandbox: comparison langtools/src/jdk.jdeps/share/classes/com/sun/tools/jdeps/ModuleInfoBuilder.java

equal deleted inserted replaced

-:ce7b7f98a236
+:9cff98a149cb
 import java.nio.file.Paths;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import static java.util.stream.Collectors.*;
 public class ModuleInfoBuilder {
 final DependencyFinder dependencyFinder;
 final Analyzer analyzer;
 // an input JAR file (loaded as an automatic module for analysis)
-// maps to an explicit module to generate module-info.java
+// maps to a normal module to generate module-info.java
-final Map<Module, Module> automaticToExplicitModule;
+final Map<Module, Module> automaticToNormalModule;
 public ModuleInfoBuilder(JdepsConfiguration configuration,
 List<String> args,
 Path outputdir,
 boolean open) {
 this.configuration = configuration;
 // add targets to modulepath if it has module-info.class
 List<Path> paths = args.stream()
 .map(fn -> Paths.get(fn))
 .collect(toList());
-// automatic module to convert to explicit module
+// automatic module to convert to normal module
-this.automaticToExplicitModule = ModuleFinder.of(paths.toArray(new Path[0]))
+this.automaticToNormalModule = ModuleFinder.of(paths.toArray(new Path[0]))
 .findAll().stream()
 .map(configuration::toModule)
 .collect(toMap(Function.identity(), Function.identity()));
-Optional<Module> om = automaticToExplicitModule.keySet().stream()
+Optional<Module> om = automaticToNormalModule.keySet().stream()
 .filter(m -> !m.descriptor().isAutomatic())
 .findAny();
 if (om.isPresent()) {
 throw new UncheckedBadArgs(new BadArgs("err.genmoduleinfo.not.jarfile",
 om.get().getPathName()));
 }
-if (automaticToExplicitModule.isEmpty()) {
+if (automaticToNormalModule.isEmpty()) {
 throw new UncheckedBadArgs(new BadArgs("err.invalid.path", args));
 }
 }
 public boolean run() throws IOException {
 : Collections.emptySet();
 Path file = outputdir.resolve(m.name()).resolve("module-info.java");
 // computes requires and requires transitive
-Module explicitModule = toExplicitModule(m, apiDeps);
+Module normalModule = toNormalModule(m, apiDeps);
-if (explicitModule != null) {
+if (normalModule != null) {
-automaticToExplicitModule.put(m, explicitModule);
+automaticToNormalModule.put(m, normalModule);
 // generate module-info.java
 System.out.format("writing to %s%n", file);
-writeModuleInfo(file,  explicitModule.descriptor());
+writeModuleInfo(file,  normalModule.descriptor());
 } else {
 // find missing dependences
 System.out.format("Missing dependence: %s not generated%n", file);
 missingDeps = true;
 }
 boolean notFound(Archive m) {
 return m == NOT_FOUND || m == REMOVED_JDK_INTERNALS;
 }
-private Module toExplicitModule(Module module, Set<Archive> requiresTransitive)
+private Module toNormalModule(Module module, Set<Archive> requiresTransitive)
 throws IOException
 {
 // done analysis
 module.close();
 analyzer.requires(module)
 .map(Archive::getModule)
 .forEach(d -> requires.putIfAbsent(d.name(), Boolean.FALSE));
-return module.toStrictModule(requires);
+return module.toNormalModule(requires);
 }
 /**
 * Returns the stream of resulting modules
 */
 Stream<Module> modules() {
-return automaticToExplicitModule.values().stream();
+return automaticToNormalModule.values().stream();
 }
 /**
 * Returns the stream of resulting ModuleDescriptors
 */
 public Stream<ModuleDescriptor> descriptors() {
-return automaticToExplicitModule.entrySet().stream()
+return automaticToNormalModule.entrySet().stream()
 .map(Map.Entry::getValue)
 .map(Module::descriptor);
 }
 void visitMissingDeps(Analyzer.Visitor visitor) {
 Map<String, Module> modules = configuration.getModules();
 // first print the JDK modules
 md.requires().stream()
 .filter(req -> !req.name().equals("java.base"))   // implicit requires
 .sorted(Comparator.comparing(Requires::name))
-.forEach(req -> writer.format("    requires %s;%n", req));
+.forEach(req -> writer.format("    requires %s;%n",
+toString(req.modifiers(), req.name())));
 if (!open) {
 md.exports().stream()
 .peek(exp -> {
-if (exp.targets().size() > 0)
+if (exp.isQualified())
 throw new InternalError(md.name() + " qualified exports: " + exp);
 })
 .sorted(Comparator.comparing(Exports::source))
 .forEach(exp -> writer.format("    exports %s;%n", exp.source()));
 }
 writer.println("}");
 }
 private Set<Module> automaticModules() {
-return automaticToExplicitModule.keySet();
+return automaticToNormalModule.keySet();
+}
+/**
+* Returns a string containing the given set of modifiers and label.
+*/
+private static <M> String toString(Set<M> mods, String what) {
+return (Stream.concat(mods.stream().map(e -> e.toString().toLowerCase(Locale.US)),
+Stream.of(what)))
+.collect(Collectors.joining(" "));
 }
 /**
 * Compute 'requires transitive' dependences by analyzing API dependencies
 */

changeset 43767	9cff98a149cb
parent 42407	f3702cff2933
child 45684	2c5f2779c3d1