jdk-sandbox: comparison langtools/src/share/classes/com/sun/tools/sjavac/JavacState.java

equal deleted inserted replaced

-:3b3e23e67329
+:3651128c74eb
 }
 needsSaving = true;
 }
 prev = new BuildState();
 now = new BuildState();
-taintedPackages = new HashSet<String>();
+taintedPackages = new HashSet<>();
-recompiledPackages = new HashSet<String>();
+recompiledPackages = new HashSet<>();
-packagesWithChangedPublicApis = new HashSet<String>();
+packagesWithChangedPublicApis = new HashSet<>();
 }
 public BuildState prev() { return prev; }
 public BuildState now() { return now; }
 /**
 * Specify which sources are visible to the compiler through -sourcepath.
 */
 public void setVisibleSources(Map<String,Source> vs) {
-visibleSrcs = new HashSet<URI>();
+visibleSrcs = new HashSet<>();
 for (String s : vs.keySet()) {
 Source src = vs.get(s);
 visibleSrcs.add(src.file().toURI());
 }
 }
 /**
 * Specify which classes are visible to the compiler through -classpath.
 */
 public void setVisibleClasses(Map<String,Source> vs) {
-visibleSrcs = new HashSet<URI>();
+visibleSrcs = new HashSet<>();
 for (String s : vs.keySet()) {
 Source src = vs.get(s);
 visibleSrcs.add(src.file().toURI());
 }
 }
 private Map<String,File> fetchPrevArtifacts(String pkg) {
 Package p = prev.packages().get(pkg);
 if (p != null) {
 return p.artifacts();
 }
-return new HashMap<String,File>();
+return new HashMap<>();
 }
 /**
 * Delete all prev artifacts in the currently tainted packages.
 */
 b.append("# I pubapi\n");
 b.append("# R arguments\n");
 b.append("R ").append(theArgs).append("\n");
 // Copy over the javac_state for the packages that did not need recompilation.
-now.copyPackagesExcept(prev, recompiledPackages, new HashSet<String>());
+now.copyPackagesExcept(prev, recompiledPackages, new HashSet<>());
 // Save the packages, ie package names, dependencies, pubapis and artifacts!
 // I.e. the lot.
 Module.saveModules(now.modules(), b);
 String s = b.toString();
 /**
 * Clean out the tainted package set, used after the first round of compiles,
 * prior to propagating dependencies.
 */
 public void clearTaintedPackages() {
-taintedPackages = new HashSet<String>();
+taintedPackages = new HashSet<>();
 }
 /**
 * Go through all sources and check which have been removed, added or modified
 * and taint the corresponding packages.
 /**
 * Acquire the compile_java_packages suffix rule for .java files.
 */
 public Map<String,Transformer> getJavaSuffixRule() {
-Map<String,Transformer> sr = new HashMap<String,Transformer>();
+Map<String,Transformer> sr = new HashMap<>();
 sr.put(".java", compileJavaPackages);
 return sr;
 }
 /**
 /**
 * Scan all output dirs for artifacts and remove those files (artifacts?)
 * that are not recognized as such, in the javac_state file.
 */
 public void removeUnidentifiedArtifacts() {
-Set<File> allKnownArtifacts = new HashSet<File>();
+Set<File> allKnownArtifacts = new HashSet<>();
 for (Package pkg : prev.packages().values()) {
 for (File f : pkg.artifacts().values()) {
 allKnownArtifacts.add(f);
 }
 }
 /**
 * Return those files belonging to prev, but not now.
 */
 private Set<Source> calculateRemovedSources() {
-Set<Source> removed = new HashSet<Source>();
+Set<Source> removed = new HashSet<>();
 for (String src : prev.sources().keySet()) {
 if (now.sources().get(src) == null) {
 removed.add(prev.sources().get(src));
 }
 }
 /**
 * Return those files belonging to now, but not prev.
 */
 private Set<Source> calculateAddedSources() {
-Set<Source> added = new HashSet<Source>();
+Set<Source> added = new HashSet<>();
 for (String src : now.sources().keySet()) {
 if (prev.sources().get(src) == null) {
 added.add(now.sources().get(src));
 }
 }
 * If a source file timestamp suddenly is older than what is known
 * about it in javac_state, then consider it modified, but print
 * a warning!
 */
 private Set<Source> calculateModifiedSources() {
-Set<Source> modified = new HashSet<Source>();
+Set<Source> modified = new HashSet<>();
 for (String src : now.sources().keySet()) {
 Source n = now.sources().get(src);
 Source t = prev.sources().get(src);
 if (prev.sources().get(src) != null) {
 if (t != null) {
 /**
 * Run the copy translator only.
 */
 public void performCopying(File binDir, Map<String,Transformer> suffixRules) {
-Map<String,Transformer> sr = new HashMap<String,Transformer>();
+Map<String,Transformer> sr = new HashMap<>();
 for (Map.Entry<String,Transformer> e : suffixRules.entrySet()) {
 if (e.getValue() == copyFiles) {
 sr.put(e.getKey(), e.getValue());
 }
 }
 /**
 * Run all the translators that translate into java source code.
 * I.e. all translators that are not copy nor compile_java_source.
 */
 public void performTranslation(File gensrcDir, Map<String,Transformer> suffixRules) {
-Map<String,Transformer> sr = new HashMap<String,Transformer>();
+Map<String,Transformer> sr = new HashMap<>();
 for (Map.Entry<String,Transformer> e : suffixRules.entrySet()) {
 if (e.getValue() != copyFiles &&
 e.getValue() != compileJavaPackages) {
 sr.put(e.getKey(), e.getValue());
 }
 public boolean performJavaCompilations(File binDir,
 String serverSettings,
 String[] args,
 Set<String> recentlyCompiled,
 boolean[] rcValue) {
-Map<String,Transformer> suffixRules = new HashMap<String,Transformer>();
+Map<String,Transformer> suffixRules = new HashMap<>();
 suffixRules.put(".java", compileJavaPackages);
 compileJavaPackages.setExtra(serverSettings);
 compileJavaPackages.setExtra(args);
 rcValue[0] = perform(binDir, suffixRules);
 recentlyCompiled.addAll(taintedPackages());
 clearTaintedPackages();
 boolean again = !packagesWithChangedPublicApis.isEmpty();
 taintPackagesDependingOnChangedPackages(packagesWithChangedPublicApis, recentlyCompiled);
-packagesWithChangedPublicApis = new HashSet<String>();
+packagesWithChangedPublicApis = new HashSet<>();
 return again && rcValue[0];
 }
 /**
 * Store the source into the set of sources belonging to the given transform.
 */
 private void addFileToTransform(Map<Transformer,Map<String,Set<URI>>> gs, Transformer t, Source s) {
 Map<String,Set<URI>> fs = gs.get(t);
 if (fs == null) {
-fs = new HashMap<String,Set<URI>>();
+fs = new HashMap<>();
 gs.put(t, fs);
 }
 Set<URI> ss = fs.get(s.pkg().name());
 if (ss == null) {
-ss = new HashSet<URI>();
+ss = new HashSet<>();
 fs.put(s.pkg().name(), ss);
 }
 ss.add(s.file().toURI());
 }
 */
 private boolean perform(File outputDir, Map<String,Transformer> suffixRules)
 {
 boolean rc = true;
 // Group sources based on transforms. A source file can only belong to a single transform.
-Map<Transformer,Map<String,Set<URI>>> groupedSources = new HashMap<Transformer,Map<String,Set<URI>>>();
+Map<Transformer,Map<String,Set<URI>>> groupedSources = new HashMap<>();
 for (Source src : now.sources().values()) {
 Transformer t = suffixRules.get(src.suffix());
 if (t != null) {
 if (taintedPackages.contains(src.pkg().name()) && !src.isLinkedOnly()) {
 addFileToTransform(groupedSources, t, src);
 // Go through the transforms and transform them.
 for (Map.Entry<Transformer,Map<String,Set<URI>>> e : groupedSources.entrySet()) {
 Transformer t = e.getKey();
 Map<String,Set<URI>> srcs = e.getValue();
 // These maps need to be synchronized since multiple threads will be writing results into them.
-Map<String,Set<URI>> packageArtifacts = Collections.synchronizedMap(new HashMap<String,Set<URI>>());
+Map<String,Set<URI>> packageArtifacts = Collections.synchronizedMap(new HashMap<>());
-Map<String,Set<String>> packageDependencies = Collections.synchronizedMap(new HashMap<String,Set<String>>());
+Map<String,Set<String>> packageDependencies = Collections.synchronizedMap(new HashMap<>());
-Map<String,String> packagePublicApis = Collections.synchronizedMap(new HashMap<String,String>());
+Map<String,String> packagePublicApis = Collections.synchronizedMap(new HashMap<>());
 boolean  r = t.transform(srcs,
 visibleSrcs,
 visibleClasses,
 prev.dependents(),
 /**
 * Utility method to recursively find all files below a directory.
 */
 private static Set<File> findAllFiles(File dir) {
-Set<File> foundFiles = new HashSet<File>();
+Set<File> foundFiles = new HashSet<>();
 if (dir == null) {
 return foundFiles;
 }
 recurse(dir, foundFiles);
 return foundFiles;
 // We need to adjust our calculated sources to be identical, if necessary.
 boolean mightNeedRewriting = File.pathSeparatorChar == ';';
 if (makefileSourceList == null) return;
-Set<String> calculatedSources = new HashSet<String>();
+Set<String> calculatedSources = new HashSet<>();
-Set<String> listedSources = new HashSet<String>();
+Set<String> listedSources = new HashSet<>();
 // Create a set of filenames with full paths.
 for (Source s : now.sources().values()) {
 // Don't include link only sources when comparing sources to compile
 if (!s.isLinkedOnly()) {

changeset 22163	3651128c74eb
parent 19500	26d88d483764
child 22165	ec53c8946fc2