jdk-sandbox: comparison src/jdk.jlink/share/classes/jdk/tools/jlink/internal/plugins/GenerateJLIClassesPlugin.java

equal deleted inserted replaced

-:6c255334120d
+:63994dedec49
 import java.util.EnumSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import jdk.internal.access.SharedSecrets;
 import jdk.internal.access.JavaLangInvokeAccess;
 import jdk.tools.jlink.plugin.ResourcePoolEntry;
 import jdk.tools.jlink.plugin.PluginException;
 private static final String INVOKERS_HOLDER_INTERNAL_NAME = INVOKERS_HOLDER_NAME.replace('.', '/');
 private static final JavaLangInvokeAccess JLIA
 = SharedSecrets.getJavaLangInvokeAccess();
-Set<String> speciesTypes = Set.of();
+private final TreeSet<String> speciesTypes = new TreeSet<>();
-Set<String> invokerTypes = Set.of();
+private final TreeSet<String> invokerTypes = new TreeSet<>();
-Set<String> callSiteTypes = Set.of();
+private final TreeSet<String> callSiteTypes = new TreeSet<>();
-Map<String, Set<String>> dmhMethods = Map.of();
+private final Map<String, Set<String>> dmhMethods = new TreeMap<>();
 String mainArgument;
 public GenerateJLIClassesPlugin() {
 }
 @Override
 public void configure(Map<String, String> config) {
 mainArgument = config.get(NAME);
 }
+private void addSpeciesType(String type) {
+speciesTypes.add(expandSignature(type));
+}
+private void addInvokerType(String methodType) {
+validateMethodType(methodType);
+invokerTypes.add(methodType);
+}
+private void addCallSiteType(String csType) {
+validateMethodType(csType);
+callSiteTypes.add(csType);
+}
 public void initialize(ResourcePool in) {
 // Start with the default configuration
-speciesTypes = defaultSpecies().stream()
+defaultSpecies().stream().forEach(this::addSpeciesType);
-.map(type -> expandSignature(type))
-.collect(Collectors.toSet());
+defaultInvokers().stream().forEach(this::validateMethodType);
-invokerTypes = defaultInvokers();
+defaultCallSiteTypes().stream().forEach(this::addCallSiteType);
-validateMethodTypes(invokerTypes);
+defaultDMHMethods().entrySet().stream().forEach(e -> {
-callSiteTypes = defaultCallSiteTypes();
+e.getValue().stream().forEach(type -> addDMHMethodType(e.getKey(), type));
+});
-dmhMethods = defaultDMHMethods();
-for (Set<String> dmhMethodTypes : dmhMethods.values()) {
-validateMethodTypes(dmhMethodTypes);
-}
 // Extend the default configuration with the contents in the supplied
 // input file - if none was supplied we look for the default file
 if (mainArgument == null || !mainArgument.startsWith("@")) {
 try (InputStream traceFile =
 }
 }
 }
 private void readTraceConfig(Stream<String> lines) {
-// Use TreeSet/TreeMap to keep things sorted in a deterministic
-// order to avoid scrambling the layout on small changes and to
-// ease finding methods in the generated code
-speciesTypes = new TreeSet<>(speciesTypes);
-invokerTypes = new TreeSet<>(invokerTypes);
-callSiteTypes = new TreeSet<>(callSiteTypes);
-TreeMap<String, Set<String>> newDMHMethods = new TreeMap<>();
-for (Map.Entry<String, Set<String>> entry : dmhMethods.entrySet()) {
-newDMHMethods.put(entry.getKey(), new TreeSet<>(entry.getValue()));
-}
-dmhMethods = newDMHMethods;
 lines.map(line -> line.split(" "))
 .forEach(parts -> {
 switch (parts[0]) {
 case "[SPECIES_RESOLVE]":
 // Allow for new types of species data classes being resolved here
 if (parts.length == 3 && parts[1].startsWith("java.lang.invoke.BoundMethodHandle$Species_")) {
 String species = parts[1].substring("java.lang.invoke.BoundMethodHandle$Species_".length());
 if (!"L".equals(species)) {
-speciesTypes.add(expandSignature(species));
+addSpeciesType(species);
 }
 }
 break;
 case "[LF_RESOLVE]":
 String methodType = parts[3];
-validateMethodType(methodType);
 if (parts[1].equals(INVOKERS_HOLDER_NAME)) {
 if ("linkToTargetMethod".equals(parts[2]) ||
 "linkToCallSite".equals(parts[2])) {
-callSiteTypes.add(methodType);
+addCallSiteType(methodType);
 } else {
-invokerTypes.add(methodType);
+addInvokerType(methodType);
 }
 } else if (parts[1].contains("DirectMethodHandle")) {
 String dmh = parts[2];
 // ignore getObject etc for now (generated
 // by default)
 private Stream<String> fileLines(File file) {
 try {
 return Files.lines(file.toPath());
 } catch (IOException io) {
 throw new PluginException("Couldn't read file");
-}
-}
-private void validateMethodTypes(Set<String> dmhMethodTypes) {
-for (String type : dmhMethodTypes) {
-validateMethodType(type);
 }
 }
 private void validateMethodType(String type) {
 String[] typeParts = type.split("_");
 // Generate LambdaForm Holder classes
 generateHolderClasses(out);
 // Let it go
-speciesTypes = null;
+speciesTypes.clear();
-invokerTypes = null;
+invokerTypes.clear();
-dmhMethods = null;
+callSiteTypes.clear();
+dmhMethods.clear();
 return out.build();
 }
 @SuppressWarnings("unchecked")

changeset 58843	63994dedec49
parent 57939	e8ba7e4f4190