Add support for MyClass.|this completion

`ThisExpression` is it's own node, which we will need to handle
differently.

Should fix 2 test cases.

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

Author: datho7561

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

@@ -121,6 +121,7 @@
 import org.eclipse.jdt.core.dom.TagElement;
 import org.eclipse.jdt.core.dom.TextBlock;
 import org.eclipse.jdt.core.dom.TextElement;
+import org.eclipse.jdt.core.dom.ThisExpression;
 import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.TypeDeclaration;
 import org.eclipse.jdt.core.dom.TypePattern;
@@ -181,6 +182,7 @@ public class DOMCompletionEngine implements ICompletionEngine {
 	private ExpectedTypes expectedTypes;
 	private String prefix;
 	private String qualifiedPrefix;
+	private ITypeBinding qualifyingType;
 	private ASTNode toComplete;
 	private String textContent;
 
@@ -543,6 +545,10 @@ public void complete(org.eclipse.jdt.internal.compiler.env.ICompilationUnit sour
 					}
 					this.qualifiedPrefix = packageName;
 				}
+			} else if (this.toComplete instanceof ThisExpression thisExpression) {
+				if (thisExpression.getQualifier() != null) {
+					this.qualifiedPrefix = thisExpression.getQualifier().toString();
+				}
 			}
 			// some flags to controls different applicable completion search strategies
 			boolean suggestDefaultCompletions = true;
@@ -1399,6 +1405,26 @@ public void complete(org.eclipse.jdt.internal.compiler.env.ICompilationUnit sour
 				}
 				suggestDefaultCompletions = false;
 			}
+			if (context instanceof ThisExpression thisExpression) {
+				if (thisExpression.getQualifier() != null) {
+					IBinding binding = thisExpression.getQualifier().resolveBinding();
+					if (binding instanceof ITypeBinding typeBinding) {
+						this.qualifyingType = typeBinding;
+						Bindings typesMembers = new Bindings();
+						processMembers(this.toComplete, typeBinding, typesMembers, true);
+						publishFromScope(typesMembers);
+						this.requestor.accept(createClassKeywordProposal(typeBinding, -1,-1));
+					}
+					for (char[] keyword : List.of(Keywords.SUPER, Keywords.THIS)) {
+						if (!isFailedMatch(this.prefix.toCharArray(), keyword)) {
+							CompletionProposal res = createKeywordProposal(keyword, -1, -1);
+							res.setRelevance(res.getRelevance() + RelevanceConstants.R_NON_INHERITED);
+							this.requestor.accept(res);
+						}
+					}
+					suggestDefaultCompletions = false;
+				}
+			}
 			if (context != null && context.getLocationInParent() == QualifiedType.NAME_PROPERTY && context.getParent() instanceof QualifiedType qType) {
 				Type qualifier = qType.getQualifier();
 				if (qualifier != null) {
@@ -2652,6 +2678,7 @@ private CompletionProposal toProposal(IBinding binding, String completion) {
 					this.toComplete.getAST().resolveWellKnownType(Object.class.getName()), this.expectedTypes) +
 				(isInQualifiedName || res.getRequiredProposals() != null || inJavadoc ? 0 : RelevanceUtils.computeRelevanceForQualification(false, this.prefix, this.qualifiedPrefix)) +
 				RelevanceConstants.R_NON_RESTRICTED +
+				RelevanceUtils.computeRelevanceForInheritance(this.qualifyingType, binding) +
 				((insideQualifiedReference() && !staticOnly() && !Modifier.isStatic(binding.getModifiers())) || (inJavadoc && !res.isConstructor()) ? RelevanceConstants.R_NON_STATIC : 0) +
 				(!staticOnly() || inheritedValue ? 0 : RelevanceConstants.R_NON_INHERITED) + // TODO: when is this active?
 				(binding instanceof IVariableBinding field && field.isEnumConstant() ? RelevanceConstants.R_ENUM + RelevanceConstants.R_ENUM_CONSTANT : 0)
@@ -2756,6 +2783,10 @@ private CompletionProposal toProposal(IType type) {
 			res.setReplaceRange(this.offset, this.offset);
 		} else if (this.toComplete instanceof SimpleName) {
 			res.setReplaceRange(this.toComplete.getStartPosition(), this.toComplete.getStartPosition() + this.toComplete.getLength());
+		} else if (this.toComplete instanceof ThisExpression thisExpression
+				&& thisExpression.getQualifier() != null
+				&& this.offset > (thisExpression.getQualifier().getStartPosition() + thisExpression.getQualifier().getLength())) {
+			setRange(res);
 		} else {
 			res.setReplaceRange(this.toComplete.getStartPosition(), this.offset);
 		}
@@ -2792,6 +2823,7 @@ private CompletionProposal toProposal(IType type) {
 				+ RelevanceConstants.R_RESOLVED
 				+ RelevanceConstants.R_INTERESTING
 				+ RelevanceConstants.R_NON_RESTRICTED
+				+ RelevanceUtils.computeRelevanceForInheritance(this.qualifyingType, type)
 				+ RelevanceUtils.computeRelevanceForQualification(!type.getFullyQualifiedName().startsWith("java.") && !nodeInImports && !fromCurrentCU && !inSamePackage && !typeIsImported, this.prefix, this.qualifiedPrefix)
 				+ (type.getFullyQualifiedName().startsWith("java.") ? RelevanceConstants.R_JAVA_LIBRARY : 0)
 				+ (expectedTypes.getExpectedTypes().stream().map(ITypeBinding::getQualifiedName).anyMatch(type.getFullyQualifiedName()::equals) ? RelevanceConstants.R_EXACT_EXPECTED_TYPE :
@@ -3511,13 +3543,21 @@ private CompletionProposal createClassKeywordProposal(ITypeBinding typeBinding,
 				+ RelevanceConstants.R_RESOLVED
 				+ RelevanceConstants.R_INTERESTING
 				+ RelevanceConstants.R_NON_RESTRICTED
-				+ RelevanceConstants.R_EXPECTED_TYPE;
-		if (!isFailedMatch(this.prefix.toCharArray(), Keywords.CLASS)) {
-			relevance += RelevanceConstants.R_SUBSTRING;
-		}
+				+ RelevanceConstants.R_NON_INHERITED
+				+ RelevanceUtils.computeRelevanceForCaseMatching(this.prefix.toCharArray(), Keywords.CLASS, assistOptions)
+//				+ RelevanceUtils.computeRelevanceForExpectingType(typeBinding, this.expectedTypes)
+				;
+		
 		DOMInternalCompletionProposal keywordProposal = createProposal(CompletionProposal.FIELD_REF);
 		keywordProposal.setCompletion(Keywords.CLASS);
-		keywordProposal.setReplaceRange(startPos, endPos);
+		
+		if (startPos == -1 && endPos == -1) {
+			setRange(keywordProposal);
+		} else {
+			keywordProposal.setReplaceRange(startPos, endPos);
+			keywordProposal.setTokenRange(startPos, endPos);
+		}
+		
 		keywordProposal.setRelevance(relevance);
 		keywordProposal.setPackageName(CharOperation.concatWith(TypeConstants.JAVA_LANG, '.'));
 		keywordProposal.setTypeName("Class".toCharArray()); //$NON-NLS-1$

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

@@ -12,10 +12,15 @@
 
 import java.util.Objects;
 
+import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.compiler.CharOperation;
+import org.eclipse.jdt.core.dom.IBinding;
+import org.eclipse.jdt.core.dom.IMethodBinding;
 import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.IVariableBinding;
 import org.eclipse.jdt.core.dom.PrimitiveType;
 import org.eclipse.jdt.internal.codeassist.impl.AssistOptions;
+import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 
 /**
  * Helper methods for calculating the relevance numbers of completion proposals.
@@ -120,4 +125,50 @@ static int computeRelevanceForExpectingType(ITypeBinding proposalType, ExpectedT
 		return 0;
 	}
 
+	/**
+	 * Returns the appropriate relevance number based on if the given member is directly implemented in the qualifying type.
+	 * 
+	 * @see CompletionEngine#computeRelevanceForInheritance(ReferenceBinding, ReferenceBinding)
+	 * @param qualifyingType the qualifying type
+	 * @param member the member to check if it's directly or indirectly inherited
+	 * @return the appropriate relevance number based on if the given member is directly implemented in the qualifying type
+	 */
+	static int computeRelevanceForInheritance(ITypeBinding qualifyingType, IBinding member) {
+		if (qualifyingType == null) {
+			return 0;
+		}
+		if (member instanceof IMethodBinding methodBinding) {
+			if (methodBinding.getDeclaringClass().getKey().equals(qualifyingType.getKey())) {
+				return RelevanceConstants.R_NON_INHERITED;
+			}
+		} else if (member instanceof IVariableBinding varBinding) {
+			if (varBinding.getDeclaringClass().getKey().equals(qualifyingType.getKey())) {
+				return RelevanceConstants.R_NON_INHERITED;
+			}
+		} else if (member instanceof ITypeBinding typeBinding) {
+			if (typeBinding.getDeclaringClass().getKey().equals(qualifyingType.getKey())) {
+				return RelevanceConstants.R_NON_INHERITED;
+			}
+		}
+		return 0;
+	}
+	
+	/**
+	 * Returns the appropriate relevance number based on if the given member type is directly implemented in the qualifying type.
+	 * 
+	 * @see CompletionEngine#computeRelevanceForInheritance(ReferenceBinding, ReferenceBinding)
+	 * @param qualifyingType the qualifying type
+	 * @param memberType the member type to check if it's directly or indirectly inherited
+	 * @return the appropriate relevance number based on if the given member is directly implemented in the qualifying type
+	 */
+	static int computeRelevanceForInheritance(ITypeBinding qualifyingType, IType memberType) {
+		if (qualifyingType == null || memberType.getDeclaringType() == null) {
+			return 0;
+		}
+		if (memberType.getDeclaringType().getKey().equals(qualifyingType.getKey())) {
+			return RelevanceConstants.R_NON_INHERITED;
+		}
+		return 0;
+	}
+
 }