jdk-sandbox: comparison langtools/src/jdk.javadoc/share/classes/jdk/javadoc/internal/tool/ElementsTable.java

equal deleted inserted replaced

-:4bd6416db3de
+:2f97c71f06f4
 import javax.tools.JavaFileManager.Location;
 import javax.tools.JavaFileObject;
 import javax.tools.StandardLocation;
 import com.sun.tools.javac.code.Kinds.Kind;
+import com.sun.tools.javac.code.Source;
 import com.sun.tools.javac.code.Symbol;
 import com.sun.tools.javac.code.Symbol.ClassSymbol;
 import com.sun.tools.javac.code.Symbol.CompletionFailure;
 import com.sun.tools.javac.code.Symbol.ModuleSymbol;
 import com.sun.tools.javac.code.Symbol.PackageSymbol;
 import com.sun.tools.javac.code.Symtab;
 import com.sun.tools.javac.comp.Modules;
+import com.sun.tools.javac.main.JavaCompiler;
 import com.sun.tools.javac.tree.JCTree.JCClassDecl;
 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.tree.JCTree.JCModuleDecl;
+import com.sun.tools.javac.tree.TreeInfo;
 import com.sun.tools.javac.util.Context;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import jdk.javadoc.doclet.DocletEnvironment;
 import jdk.javadoc.doclet.DocletEnvironment.ModuleMode;
 import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
 import static javax.tools.JavaFileObject.Kind.*;
 import static jdk.javadoc.internal.tool.Main.Result.*;
 import static jdk.javadoc.internal.tool.JavadocTool.isValidClassName;
 /**
 private final ToolEnvironment toolEnv;
 private final Symtab syms;
 private final Names names;
 private final JavaFileManager fm;
-private final Location location;
+private final List<Location> locations;
 private final Modules modules;
 private final Map<ToolOption, Object> opts;
 private final Messager messager;
+private final JavaCompiler compiler;
 private final Map<String, Entry> entries = new LinkedHashMap<>();
 // specified elements
 private Set<ModuleElement> specifiedModuleElements = new LinkedHashSet<>();
 this.names = Names.instance(context);
 this.fm = toolEnv.fileManager;
 this.modules = Modules.instance(context);
 this.opts = opts;
 this.messager = Messager.instance0(context);
+this.compiler = JavaCompiler.instance(context);
-this.location = modules.multiModuleMode
+Source source = Source.instance(context);
-? StandardLocation.MODULE_SOURCE_PATH
-: toolEnv.fileManager.hasLocation(StandardLocation.SOURCE_PATH)
+List<Location> locs = new ArrayList<>();
-? StandardLocation.SOURCE_PATH
+if (modules.multiModuleMode) {
-: StandardLocation.CLASS_PATH;
+locs.add(StandardLocation.MODULE_SOURCE_PATH);
+} else {
+if (toolEnv.fileManager.hasLocation(StandardLocation.SOURCE_PATH))
+locs.add(StandardLocation.SOURCE_PATH);
+else
+locs.add(StandardLocation.CLASS_PATH);
+}
+if (source.allowModules() && toolEnv.fileManager.hasLocation(StandardLocation.PATCH_MODULE_PATH))
+locs.add(StandardLocation.PATCH_MODULE_PATH);
+this.locations = Collections.unmodifiableList(locs);
 getEntry("").excluded = false;
 accessFilter = new ModifierFilter(opts);
 xclasses = (boolean)opts.getOrDefault(ToolOption.XCLASSES, false);
 expandRequires = (AccessKind)opts.get(ToolOption.EXPAND_REQUIRES);
 ElementsTable classTrees(com.sun.tools.javac.util.List<JCCompilationUnit> classTrees) {
 this.classTreeList = classTrees;
 return this;
 }
+/*
+* This method sanity checks the following cases:
+* a. a source-path containing a single module and many modules specified with --module
+* b. no modules on source-path
+* c. mismatched source-path and many modules specified with --module
+*/
+void sanityCheckSourcePathModules(List<String> moduleNames) throws ToolException {
+if (!haveSourceLocationWithModule)
+return;
+if (moduleNames.size() > 1) {
+String text = messager.getText("main.cannot_use_sourcepath_for_modules",
+String.join(", ", moduleNames));
+throw new ToolException(CMDERR, text);
+}
+String foundModule = getModuleName(StandardLocation.SOURCE_PATH);
+if (foundModule == null) {
+String text = messager.getText("main.module_not_found_on_sourcepath", moduleNames.get(0));
+throw new ToolException(CMDERR, text);
+}
+if (!moduleNames.get(0).equals(foundModule)) {
+String text = messager.getText("main.sourcepath_does_not_contain_module", moduleNames.get(0));
+throw new ToolException(CMDERR, text);
+}
+}
+private String getModuleName(Location location) throws ToolException {
+try {
+JavaFileObject jfo = fm.getJavaFileForInput(location,
+"module-info", JavaFileObject.Kind.SOURCE);
+if (jfo != null) {
+JCCompilationUnit jcu = compiler.parse(jfo);
+JCModuleDecl module = TreeInfo.getModule(jcu);
+if (module != null) {
+return module.getName().toString();
+}
+}
+} catch (IOException ioe) {
+String text = messager.getText("main.file.manager.list", location);
+throw new ToolException(SYSERR, text, ioe);
+}
+return null;
+}
 @SuppressWarnings("unchecked")
 ElementsTable scanSpecifiedItems() throws ToolException {
 // scan modules specified on the command line
 List<String> moduleNames = (List<String>) opts.computeIfAbsent(ToolOption.MODULE,
 s -> Collections.EMPTY_LIST);
 List<String> mlist = new ArrayList<>();
 for (String m : moduleNames) {
-Location moduleLoc = getModuleLocation(location, m);
+List<Location> moduleLocations = getModuleLocation(locations, m);
-if (moduleLoc == null) {
+if (moduleLocations.isEmpty()) {
 String text = messager.getText("main.module_not_found", m);
 throw new ToolException(CMDERR, text);
-} else {
+}
-mlist.add(m);
+if (moduleLocations.contains(StandardLocation.SOURCE_PATH)) {
-ModuleSymbol msym = syms.enterModule(names.fromString(m));
+sanityCheckSourcePathModules(moduleNames);
-specifiedModuleElements.add((ModuleElement) msym);
+}
-}
+mlist.add(m);
+ModuleSymbol msym = syms.enterModule(names.fromString(m));
+specifiedModuleElements.add((ModuleElement) msym);
 }
 // scan for modules with qualified packages
 cmdLinePackages.stream()
 .filter((mpkg) -> (mpkg.hasModule()))
 excludePackages.forEach((p) -> {
 getEntry(p).excluded = true;
 });
 for (ModulePackage modpkg : subPackages) {
-Location packageLocn = getLocation(modpkg);
+List<Location> locs = getLocation(modpkg);
-Iterable<JavaFileObject> list = null;
+for (Location loc : locs) {
-try {
+addPackagesFromLocations(loc, modpkg);
-list = fm.list(packageLocn, modpkg.packageName, sourceKinds, true);
+}
-} catch (IOException ioe) {
+}
-String text = messager.getText("main.file.manager.list", modpkg.packageName);
+}
-throw new ToolException(SYSERR, text, ioe);
-}
+private void addPackagesFromLocations(Location packageLocn, ModulePackage modpkg) throws ToolException {
-for (JavaFileObject fo : list) {
+Iterable<JavaFileObject> list = null;
-String binaryName = fm.inferBinaryName(packageLocn, fo);
+try {
-String pn = getPackageName(binaryName);
+list = fm.list(packageLocn, modpkg.packageName, sourceKinds, true);
-String simpleName = getSimpleName(binaryName);
+} catch (IOException ioe) {
-Entry e = getEntry(pn);
+String text = messager.getText("main.file.manager.list", modpkg.packageName);
-if (!e.isExcluded() && isValidClassName(simpleName)) {
+throw new ToolException(SYSERR, text, ioe);
-ModuleSymbol msym = (modpkg.hasModule())
+}
-? syms.getModule(names.fromString(modpkg.moduleName))
+for (JavaFileObject fo : list) {
-: findModuleOfPackageName(modpkg.packageName);
+String binaryName = fm.inferBinaryName(packageLocn, fo);
+String pn = getPackageName(binaryName);
-if (msym != null && !msym.isUnnamed()) {
+String simpleName = getSimpleName(binaryName);
-syms.enterPackage(msym, names.fromString(pn));
+Entry e = getEntry(pn);
-ModulePackage npkg = new ModulePackage(msym.toString(), pn);
+if (!e.isExcluded() && isValidClassName(simpleName)) {
-cmdLinePackages.add(npkg);
+ModuleSymbol msym = (modpkg.hasModule())
-} else {
+? syms.getModule(names.fromString(modpkg.moduleName))
-cmdLinePackages.add(e.modpkg);
+: findModuleOfPackageName(modpkg.packageName);
-}
-e.files = (e.files == null
+if (msym != null && !msym.isUnnamed()) {
-? com.sun.tools.javac.util.List.of(fo)
+syms.enterPackage(msym, names.fromString(pn));
-: e.files.prepend(fo));
+ModulePackage npkg = new ModulePackage(msym.toString(), pn);
-}
+cmdLinePackages.add(npkg);
+} else {
+cmdLinePackages.add(e.modpkg);
+}
+e.files = (e.files == null
+? com.sun.tools.javac.util.List.of(fo)
+: e.files.prepend(fo));
 }
 }
 }
 /**
 }
 private Set<PackageElement> getAllModulePackages(ModuleElement mdle) throws ToolException {
 Set<PackageElement> result = new HashSet<>();
 ModuleSymbol msym = (ModuleSymbol) mdle;
-Location msymloc = getModuleLocation(location, msym.name.toString());
+List<Location> msymlocs = getModuleLocation(locations, msym.name.toString());
-try {
+for (Location msymloc : msymlocs) {
-for (JavaFileObject fo : fm.list(msymloc, "", sourceKinds, true)) {
+try {
-if (fo.getName().endsWith("module-info.java"))
+for (JavaFileObject fo : fm.list(msymloc, "", sourceKinds, true)) {
-continue;
+if (fo.getName().endsWith("module-info.java")) {
-String binaryName = fm.inferBinaryName(msymloc, fo);
+continue;
-String pn = getPackageName(binaryName);
+}
-PackageSymbol psym = syms.enterPackage(msym, names.fromString(pn));
+String binaryName = fm.inferBinaryName(msymloc, fo);
-result.add((PackageElement) psym);
+String pn = getPackageName(binaryName);
-}
+PackageSymbol psym = syms.enterPackage(msym, names.fromString(pn));
+result.add((PackageElement) psym);
-} catch (IOException ioe) {
+}
-String text = messager.getText("main.file.manager.list", msymloc.getName());
-throw new ToolException(SYSERR, text, ioe);
+} catch (IOException ioe) {
+String text = messager.getText("main.file.manager.list", msymloc.getName());
+throw new ToolException(SYSERR, text, ioe);
+}
 }
 return result;
 }
 private Set<PackageElement> computeModulePackages() throws ToolException {
 if (e.files != null) {
 return e.files;
 }
 ListBuffer<JavaFileObject> lb = new ListBuffer<>();
-Location packageLocn = getLocation(modpkg);
+List<Location> locs = getLocation(modpkg);
-if (packageLocn == null) {
+if (locs.isEmpty()) {
 return Collections.emptyList();
 }
 String pname = modpkg.packageName;
+for (Location packageLocn : locs) {
 try {
 for (JavaFileObject fo : fm.list(packageLocn, pname, sourceKinds, recurse)) {
 String binaryName = fm.inferBinaryName(packageLocn, fo);
 String simpleName = getSimpleName(binaryName);
 if (isValidClassName(simpleName)) {
 lb.append(fo);
 }
 }
 } catch (IOException ioe) {
 String text = messager.getText("main.file.manager.list", pname);
 throw new ToolException(SYSERR, text, ioe);
 }
+}
 return lb.toList();
 }
 private ModuleSymbol findModuleOfPackageName(String packageName) {
 Name pack = names.fromString(packageName);
 }
 }
 return null;
 }
-private Location getLocation(ModulePackage modpkg) throws ToolException {
+private List<Location> getLocation(ModulePackage modpkg) throws ToolException {
-if (location != StandardLocation.MODULE_SOURCE_PATH) {
+if (locations.size() == 1 && !locations.contains(StandardLocation.MODULE_SOURCE_PATH)) {
-return location;
+return Collections.singletonList(locations.get(0));
 }
 if (modpkg.hasModule()) {
-return getModuleLocation(location, modpkg.moduleName);
+return getModuleLocation(locations, modpkg.moduleName);
 }
 // TODO: handle invalid results better.
 ModuleSymbol msym = findModuleOfPackageName(modpkg.packageName);
 if (msym == null) {
-return null;
+return Collections.emptyList();
 }
-return getModuleLocation(location, msym.name.toString());
+return getModuleLocation(locations, msym.name.toString());
 }
-private Location getModuleLocation(Location location, String msymName)
+boolean haveSourceLocationWithModule = false;
-throws ToolException {
+private List<Location> getModuleLocation(List<Location> locations, String msymName) throws ToolException {
+List<Location> out = new ArrayList<>();
+// search in the patch module first, this overrides others
+if (locations.contains(StandardLocation.PATCH_MODULE_PATH)) {
+Location loc = getModuleLocation(StandardLocation.PATCH_MODULE_PATH, msymName);
+if (loc != null)
+out.add(loc);
+}
+for (Location location : locations) {
+// skip patch module, already done
+if (location == StandardLocation.PATCH_MODULE_PATH) {
+continue;
+} else if (location == StandardLocation.MODULE_SOURCE_PATH) {
+Location loc = getModuleLocation(location, msymName);
+if (loc != null)
+out.add(loc);
+} else if (location == StandardLocation.SOURCE_PATH) {
+haveSourceLocationWithModule = true;
+out.add(StandardLocation.SOURCE_PATH);
+}
+}
+return out;
+}
+private Location getModuleLocation(Location location, String msymName) throws ToolException {
 try {
 return fm.getLocationForModule(location, msymName);
 } catch (IOException ioe) {
 String text = messager.getText("main.doclet_could_not_get_location", msymName);
 throw new ToolException(ERROR, text, ioe);

changeset 44301	2f97c71f06f4
parent 43265	4ec472ee5135
child 44389	a745e6ff79a5