Refactoring: Improve listClassPathHints() performance

The binary class path Set has the tendency to have duplicated roots.
The added deduplication pass ensures that findSourceRoots2 isn't called
more often than necessary.

This can significantly improve the performance during code inspect and
transform actions, esp when many projects are open.

Author: mbien

java/java.hints.declarative/src/org/netbeans/modules/java/hints/declarative/DeclarativeHintRegistry.java

@@ -106,7 +106,7 @@ public Collection<? extends HintDescription> computeHints(final ClassPath cp, At
     }
 
     public static Collection<? extends HintDescription> join(Map<HintMetadata, Collection<? extends HintDescription>> hints) {
-        List<HintDescription> descs = new LinkedList<>();
+        List<HintDescription> descs = new ArrayList<>();
 
         for (Collection<? extends HintDescription> c : hints.values()) {
             descs.addAll(c);

java/spi.java.hints/src/org/netbeans/modules/java/hints/spiimpl/Utilities.java

@@ -94,6 +94,7 @@
 import java.lang.ref.WeakReference;
 import java.net.URI;
 import java.nio.CharBuffer;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -163,8 +164,6 @@
 import org.openide.util.NbCollections;
 import org.openide.util.WeakListeners;
 import org.openide.util.lookup.ServiceProvider;
-
-import static com.sun.source.tree.CaseTree.CaseKind.STATEMENT;
 import org.netbeans.api.annotations.common.NullAllowed;
 import org.netbeans.modules.java.hints.providers.spi.HintMetadata;
 import org.netbeans.modules.refactoring.spi.ui.RefactoringUI;
@@ -175,6 +174,8 @@
 import org.openide.util.Parameters;
 import org.openide.windows.TopComponent;
 
+import static com.sun.source.tree.CaseTree.CaseKind.STATEMENT;
+
 /**
  *
  * @author Jan Lahoda
@@ -288,32 +289,36 @@ public static List<HintDescription> listAllHints(Set<ClassPath> cps) {
     }
 
     public static List<HintDescription> listClassPathHints(Set<ClassPath> sourceCPs, Set<ClassPath> binaryCPs) {
-        List<HintDescription> result = new LinkedList<>();
-        Set<FileObject> roots = new HashSet<>();
 
+        // deduplicate before running queries
+        Set<FileObject> unique = new HashSet<>(128);
         for (ClassPath cp : binaryCPs) {
-            for (FileObject r : cp.getRoots()) {
-                Result2 src = SourceForBinaryQuery.findSourceRoots2(r.toURL());
+            unique.addAll(Arrays.asList(cp.getRoots()));
+        }
 
-                if (src != null && src.preferSources()) {
-                    roots.addAll(Arrays.asList(src.getRoots()));
-                } else {
-                    roots.add(r);
-                }
+        Set<FileObject> roots = new HashSet<>();
+
+        for (FileObject fo : unique) {
+            Result2 src = SourceForBinaryQuery.findSourceRoots2(fo.toURL());
+            if (src != null && src.preferSources()) {
+                roots.addAll(Arrays.asList(src.getRoots()));
+            } else {
+                roots.add(fo);
             }
         }
 
         Set<ClassPath> cps = new HashSet<>(sourceCPs);
-
         cps.add(ClassPathSupport.createClassPath(roots.toArray(FileObject[]::new)));
 
         ClassPath cp = ClassPathSupport.createProxyClassPath(cps.toArray(ClassPath[]::new));
 
-        for (ClassPathBasedHintProvider p : Lookup.getDefault().lookupAll(ClassPathBasedHintProvider.class)) {
-            result.addAll(p.computeHints(cp, new AtomicBoolean()));
+        List<HintDescription> descriptions = new ArrayList<>();
+
+        for (ClassPathBasedHintProvider prov : Lookup.getDefault().lookupAll(ClassPathBasedHintProvider.class)) {
+            descriptions.addAll(prov.computeHints(cp, new AtomicBoolean()));
         }
 
-        return result;
+        return descriptions;
     }
 
     public static Tree parseAndAttribute(CompilationInfo info, String pattern, Scope scope) {