Cache type hierarchy in DOMCompletionUtil.findInSupers

Speeds up completion of types significantly,
since the type hierarchy of `java.lang.Exception` is only created once
every completion invocation.

Signed-off-by: David Thompson <[email protected]>

Author: datho7561

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/core/dom/JavacBindingResolver.java

@@ -19,7 +19,6 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import javax.lang.model.element.Element;

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/internal/codeassist/DOMCompletionEngine.java

@@ -209,6 +209,8 @@ public class DOMCompletionEngine implements ICompletionEngine {
 	private ASTNode toComplete;
 	private String textContent;
 	private ExtendsOrImplementsInfo extendsOrImplementsInfo;
+	
+	private Map<String, ITypeHierarchy> typeHierarchyCache = new HashMap<>();
 
 	class Bindings {
 		// those need to be list since the order matters
@@ -4126,7 +4128,7 @@ private CompletionProposal toProposal(IType type) {
 			inSamePackage = type.getPackageFragment().getElementName().isEmpty();
 		}
 		boolean inCatchClause = DOMCompletionUtil.findParent(this.toComplete, new int[] { ASTNode.CATCH_CLAUSE }) != null;
-		boolean subclassesException = DOMCompletionUtil.findInSupers(type, "Ljava/lang/Exception;");
+		boolean subclassesException = DOMCompletionUtil.findInSupers(type, "Ljava/lang/Exception;", this.workingCopyOwner, this.typeHierarchyCache);
 		int relevance = RelevanceConstants.R_DEFAULT
 				+ RelevanceConstants.R_RESOLVED
 				+ RelevanceUtils.computeRelevanceForInteresting(type, expectedTypes)
@@ -4136,7 +4138,7 @@ private CompletionProposal toProposal(IType type) {
 				+ RelevanceUtils.computeRelevanceForQualification(!type.getFullyQualifiedName().startsWith("java.") && !nodeInImports && !fromCurrentCU && !inSamePackage && !typeIsImported, this.prefix, this.qualifiedPrefix)
 				+ (type.getFullyQualifiedName().startsWith("java.") ? RelevanceConstants.R_JAVA_LIBRARY : 0)
 				// sometimes subclasses and superclasses are considered, sometimes they aren't
-				+ (inCatchClause ? RelevanceUtils.computeRelevanceForExpectingType(type, expectedTypes) : RelevanceUtils.simpleComputeRelevanceForExpectingType(type, expectedTypes))
+				+ (inCatchClause ? RelevanceUtils.computeRelevanceForExpectingType(type, expectedTypes, this.workingCopyOwner, this.typeHierarchyCache) : RelevanceUtils.simpleComputeRelevanceForExpectingType(type, expectedTypes))
 				+ RelevanceUtils.computeRelevanceForCaseMatching(this.prefix.toCharArray(), simpleName, this.assistOptions);
 		try {
 			if (type.isAnnotation()) {

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/internal/codeassist/DOMCompletionUtil.java

@@ -13,6 +13,7 @@
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
 import java.util.function.Consumer;
@@ -21,6 +22,8 @@
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.ITypeHierarchy;
 import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jdt.core.WorkingCopyOwner;
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.ASTVisitor;
 import org.eclipse.jdt.core.dom.AbstractTypeDeclaration;
@@ -145,30 +148,43 @@ public static boolean findInSupers(ITypeBinding root, String keyOfTypeToFind) {
 		}
 		return false;
 	}
-	
+
 	/**
 	 * Returns true if the type indicated by keyOfTypeToFind is a superclass of root.
 	 * 
-	 * @param root the class to begin searching in
-	 * @param keyOfTypeToFind the key of the class to find
+	 * @param root             the class to begin searching in
+	 * @param keyOfTypeToFind  the key of the class to find
+	 * @param workignCopyOwner the working copy owner
+	 * @param hierarchyCache   the cache of existing type hierarchies (rebuilding
+	 *                         the type hierarchy is very expensive)
 	 * @return true if the type indicated by keyOfTypeToFind is a superclass of root
 	 */
-	public static boolean findInSupers(IType root, String keyOfTypeToFind) {
+	public static boolean findInSupers(IType root, String keyOfTypeToFind, WorkingCopyOwner workingCopyOwner, Map<String, ITypeHierarchy> hierarchyCache) {
 		if (root.getKey().equals(keyOfTypeToFind)) {
 			return true;
 		}
-		ITypeHierarchy hierarchy;
 		try {
-			hierarchy = root.newSupertypeHierarchy(new NullProgressMonitor());
-			for (IType superType : hierarchy.getAllSupertypes(root)) {
-				if (superType.getKey().equals(keyOfTypeToFind)) {
-					return true;
+			String signature = SignatureUtils.getSignatureForTypeKey(keyOfTypeToFind);
+			IType typeToFind = root.getJavaProject().findType(Signature.getSignatureQualifier(signature)+ "." + Signature.getSignatureSimpleName(signature));
+			if (typeToFind != null) {
+				ITypeHierarchy hierarchy;
+				if (hierarchyCache.containsKey(keyOfTypeToFind)) {
+					hierarchy = hierarchyCache.get(keyOfTypeToFind);
+				} else {
+					hierarchy = typeToFind.newTypeHierarchy(root.getJavaProject(), workingCopyOwner, new NullProgressMonitor());
+					hierarchyCache.put(keyOfTypeToFind, hierarchy);
+				}
+				
+				for (IType subType : hierarchy.getAllSubtypes(typeToFind)) {
+					if (subType.getKey().equals(root.getKey())) {
+						return true;
+					}
 				}
 			}
 			return false;
 		} catch (JavaModelException e) {
 			return false;
 		}
 	}
-	
+
 }

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/internal/codeassist/RelevanceUtils.java

@@ -10,12 +10,15 @@
  *******************************************************************************/
 package org.eclipse.jdt.internal.codeassist;
 
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IPackageFragment;
 import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeHierarchy;
+import org.eclipse.jdt.core.WorkingCopyOwner;
 import org.eclipse.jdt.core.compiler.CharOperation;
 import org.eclipse.jdt.core.dom.IBinding;
 import org.eclipse.jdt.core.dom.IMethodBinding;
@@ -134,7 +137,7 @@ static int computeRelevanceForExpectingType(ITypeBinding proposalType, ExpectedT
 		return 0;
 	}
 
-	static int computeRelevanceForExpectingType(IType proposalType, ExpectedTypes expectedTypes) {
+	static int computeRelevanceForExpectingType(IType proposalType, ExpectedTypes expectedTypes, WorkingCopyOwner workingCopyOwner, Map<String, ITypeHierarchy> typeHierarchyCache) {
 		if (proposalType != null) {
 			IPackageFragment packageFragment = (IPackageFragment)proposalType.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
 			int relevance = 0;
@@ -145,7 +148,7 @@ static int computeRelevanceForExpectingType(IType proposalType, ExpectedTypes ex
 			}
 			for (ITypeBinding expectedType : expectedTypes.getExpectedTypes()) {
 				if(expectedTypes.allowsSubtypes()
-						&& DOMCompletionUtil.findInSupers(proposalType, expectedType.getKey())) {
+						&& DOMCompletionUtil.findInSupers(proposalType, expectedType.getKey(), workingCopyOwner, typeHierarchyCache)) {
 					if (expectedType.getKey().equals(proposalType.getKey())) {
 						return RelevanceConstants.R_EXACT_EXPECTED_TYPE;
 						// ??? I'm just guessing on the default packages name here, it might be the empty string