jdk-sandbox: comparison make/langtools/src/classes/build/tools/symbolgenerator/CreateSymbols.java

equal deleted inserted replaced

-:ec03768578c2
+:bf1d479fe7eb
 //<editor-fold defaultstate="collapsed" desc="ct.sym construction">
 /**Create sig files for ct.sym reading the classes description from the directory that contains
 * {@code ctDescriptionFile}, using the file as a recipe to create the sigfiles.
 */
 @SuppressWarnings("unchecked")
-public void createSymbols(String ctDescriptionFileExtra, String ctDescriptionFile, String ctSymLocation, CtSymKind ctSymKind) throws IOException {
+public void createSymbols(String ctDescriptionFileExtra, String ctDescriptionFile, String ctSymLocation) throws IOException {
 LoadDescriptions data = load(ctDescriptionFileExtra != null ? Paths.get(ctDescriptionFileExtra)
 : null,
 Paths.get(ctDescriptionFile), null);
 splitHeaders(data.classes);
+Map<String, Map<Character, String>> package2Version2Module = new HashMap<>();
 for (ModuleDescription md : data.modules.values()) {
 for (ModuleHeaderDescription mhd : md.header) {
 List<String> versionsList =
 Collections.singletonList(mhd.versions);
 writeModulesForVersions(ctSymLocation,
 md,
 mhd,
 versionsList);
+mhd.exports.stream().forEach(pkg -> {
+for (char v : mhd.versions.toCharArray()) {
+package2Version2Module.computeIfAbsent(pkg, dummy -> new HashMap<>()).put(v, md.name);
+}
+});
 }
 }
 for (ClassDescription classDescription : data.classes) {
+Map<Character, String> version2Module = package2Version2Module.getOrDefault(classDescription.packge().replace('.', '/'), Collections.emptyMap());
 for (ClassHeaderDescription header : classDescription.header) {
-switch (ctSymKind) {
+Set<String> jointVersions = new HashSet<>();
-case JOINED_VERSIONS:
+jointVersions.add(header.versions);
-Set<String> jointVersions = new HashSet<>();
+limitJointVersion(jointVersions, classDescription.fields);
-jointVersions.add(header.versions);
+limitJointVersion(jointVersions, classDescription.methods);
-limitJointVersion(jointVersions, classDescription.fields);
+Map<String, StringBuilder> module2Versions = new HashMap<>();
-limitJointVersion(jointVersions, classDescription.methods);
+for (char v : header.versions.toCharArray()) {
-writeClassesForVersions(ctSymLocation, classDescription, header, jointVersions);
+String module = version2Module.get(v);
-break;
+if (module == null) {
-case SEPARATE:
+if (v >= '9') {
-Set<String> versions = new HashSet<>();
+throw new AssertionError("No module for " + classDescription.name +
-for (char v : header.versions.toCharArray()) {
+" and version " + v);
-versions.add("" + v);
 }
-writeClassesForVersions(ctSymLocation, classDescription, header, versions);
+module = version2Module.get('9');
-break;
+if (module == null) {
+module = "java.base";
+}
+}
+module2Versions.computeIfAbsent(module, dummy -> new StringBuilder()).append(v);
+}
+for (Entry<String, StringBuilder> e : module2Versions.entrySet()) {
+Set<String> currentVersions = new HashSet<>(jointVersions);
+limitJointVersion(currentVersions, e.getValue().toString());
+currentVersions = currentVersions.stream().filter(vers -> !disjoint(vers, e.getValue().toString())).collect(Collectors.toSet());
+writeClassesForVersions(ctSymLocation, classDescription, header, e.getKey(), currentVersions);
 }
 }
 }
 }
 newHeader.flags = header.flags;
 newHeader.implementsAttr = header.implementsAttr;
 newHeader.innerClasses = header.innerClasses;
 newHeader.runtimeAnnotations = header.runtimeAnnotations;
 newHeader.signature = header.signature;
-newHeader.versions = reduce(versions, header.versions);
+newHeader.versions = reduce(header.versions, versions);
 newHeaders.add(newHeader);
 }
 }
 }
 }
 void limitJointVersion(Set<String> jointVersions, List<? extends FeatureDescription> features) {
 for (FeatureDescription feature : features) {
-for (String version : jointVersions) {
+limitJointVersion(jointVersions, feature.versions);
-if (!containsAll(feature.versions, version) &&
+}
-!disjoint(feature.versions, version)) {
+}
-StringBuilder featurePart = new StringBuilder();
-StringBuilder otherPart = new StringBuilder();
+void limitJointVersion(Set<String> jointVersions, String versions) {
-for (char v : version.toCharArray()) {
+for (String version : jointVersions) {
-if (feature.versions.indexOf(v) != (-1)) {
+if (!containsAll(versions, version) &&
-featurePart.append(v);
+!disjoint(versions, version)) {
-} else {
+StringBuilder featurePart = new StringBuilder();
-otherPart.append(v);
+StringBuilder otherPart = new StringBuilder();
-}
+for (char v : version.toCharArray()) {
+if (versions.indexOf(v) != (-1)) {
+featurePart.append(v);
+} else {
+otherPart.append(v);
 }
-jointVersions.remove(version);
+}
-if (featurePart.length() == 0 || otherPart.length() == 0) {
+jointVersions.remove(version);
-throw new AssertionError();
+if (featurePart.length() == 0 || otherPart.length() == 0) {
-}
+throw new AssertionError();
-jointVersions.add(featurePart.toString());
+}
-jointVersions.add(otherPart.toString());
+jointVersions.add(featurePart.toString());
-break;
+jointVersions.add(otherPart.toString());
-}
+break;
 }
 }
 }
 private static boolean containsAll(String versions, String subVersions) {
 }
 void writeClassesForVersions(String ctSymLocation,
 ClassDescription classDescription,
 ClassHeaderDescription header,
+String module,
 Iterable<String> versions)
 throws IOException {
 for (String ver : versions) {
-writeClass(ctSymLocation, classDescription, header, ver);
+writeClass(ctSymLocation, classDescription, header, module, ver);
 }
 }
 void writeModulesForVersions(String ctSymLocation,
 ModuleDescription moduleDescription,
 Iterable<String> versions)
 throws IOException {
 for (String ver : versions) {
 writeModule(ctSymLocation, moduleDescription, header, ver);
 }
-}
-public enum CtSymKind {
-JOINED_VERSIONS,
-SEPARATE;
 }
 //<editor-fold defaultstate="collapsed" desc="Class Writing">
 void writeModule(String ctSymLocation,
 ModuleDescription moduleDescription,
 new Field[0],
 new Method[0],
 attributes);
 Path outputClassFile = Paths.get(ctSymLocation,
-version + "-modules",
+version,
 moduleDescription.name,
 "module-info" + EXTENSION);
 Files.createDirectories(outputClassFile.getParent());
 }
 void writeClass(String ctSymLocation,
 ClassDescription classDescription,
 ClassHeaderDescription header,
+String module,
 String version) throws IOException {
 List<CPInfo> constantPool = new ArrayList<>();
 constantPool.add(null);
 List<Method> methods = new ArrayList<>();
 for (MethodDescription methDesc : classDescription.methods) {
 interfaces,
 fields.toArray(new Field[0]),
 methods.toArray(new Method[0]),
 attributes);
-Path outputClassFile = Paths.get(ctSymLocation, version, classDescription.name + EXTENSION);
+Path outputClassFile = Paths.get(ctSymLocation, version);
+if (module != null) {
+outputClassFile = outputClassFile.resolve(module);
+}
+outputClassFile = outputClassFile.resolve(classDescription.name + EXTENSION);
 Files.createDirectories(outputClassFile.getParent());
 try (OutputStream out = Files.newOutputStream(outputClassFile)) {
 ClassWriter w = new ClassWriter();
 return ;
 }
 new CreateSymbols().createSymbols(ctDescriptionFileExtra,
 ctDescriptionFile,
-ctSymLocation,
+ctSymLocation);
-CtSymKind.JOINED_VERSIONS);
 break;
 }
 }
 }

changeset 51832	bf1d479fe7eb
parent 51799	3fabe59fe4de
child 53696	f0f8f0afed74