Match SingleMemberAnnotation value()

Author: mickaelistria

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/internal/core/search/DOMJavaSearchDelegate.java

@@ -60,6 +60,7 @@
 import org.eclipse.jdt.core.dom.ParameterizedType;
 import org.eclipse.jdt.core.dom.QualifiedName;
 import org.eclipse.jdt.core.dom.SimpleType;
+import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
 import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
 import org.eclipse.jdt.core.dom.SuperMethodInvocation;
 import org.eclipse.jdt.core.dom.Type;
@@ -83,6 +84,7 @@
 import org.eclipse.jdt.internal.core.search.matching.DOMPatternLocator;
 import org.eclipse.jdt.internal.core.search.matching.MatchLocator;
 import org.eclipse.jdt.internal.core.search.matching.MatchingNodeSet;
+import org.eclipse.jdt.internal.core.search.matching.MethodPattern;
 import org.eclipse.jdt.internal.core.search.matching.NodeSetWrapper;
 import org.eclipse.jdt.internal.core.search.matching.PossibleMatch;
 
@@ -232,6 +234,9 @@ private org.eclipse.jdt.core.ICompilationUnit findUnitForPossibleMatch(MatchLoca
 	}
 
 	private SearchMatch toMatch(MatchLocator locator, org.eclipse.jdt.core.dom.ASTNode node, int accuracy, PossibleMatch possibleMatch) {
+		if (node == null) {
+			return null;
+		}
 		SearchMatch sm = toCoreMatch(locator, node, accuracy, possibleMatch);
 		if( accuracy == SearchPattern.R_ERASURE_MATCH) {
 			sm.setRule(SearchPattern.R_ERASURE_MATCH);
@@ -297,6 +302,12 @@ private SearchMatch toCoreMatch(MatchLocator locator, org.eclipse.jdt.core.dom.A
 					constructorRef.resolveMethodBinding().isSynthetic(), true, insideDocComment(node), getParticipant(locator),
 					resource);
 		}
+		if (node.getLocationInParent() == SingleMemberAnnotation.VALUE_PROPERTY && locator.pattern instanceof MethodPattern) {
+			return new MethodReferenceMatch(DOMASTNodeUtils.getEnclosingJavaElement(node), accuracy,
+					node.getStartPosition(), node.getLength(), true,
+					false, true, insideDocComment(node), getParticipant(locator),
+					resource);
+		}
 		if (node instanceof EnumConstantDeclaration enumConstantDeclaration) {
 			int start = enumConstantDeclaration.getStartPosition();
 			int len = enumConstantDeclaration.getLength();
@@ -359,7 +370,7 @@ private SearchMatch toCoreMatch(MatchLocator locator, org.eclipse.jdt.core.dom.A
 			// more...?
 		}
 		if (node.getLocationInParent() == SimpleType.NAME_PROPERTY
-				|| node.getLocationInParent() == QualifiedName.NAME_PROPERTY) {
+			|| node.getLocationInParent() == QualifiedName.NAME_PROPERTY) {
 			// more...?
 			return toMatch(locator, node.getParent(), accuracy, possibleMatch);
 		}

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/internal/core/search/PatternLocatorVisitor.java

@@ -21,6 +21,9 @@
 import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
 import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
 import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
+import org.eclipse.jdt.core.dom.ArrayInitializer;
+import org.eclipse.jdt.core.dom.BooleanLiteral;
+import org.eclipse.jdt.core.dom.CharacterLiteral;
 import org.eclipse.jdt.core.dom.ClassInstanceCreation;
 import org.eclipse.jdt.core.dom.ConstructorInvocation;
 import org.eclipse.jdt.core.dom.CreationReference;
@@ -35,6 +38,8 @@
 import org.eclipse.jdt.core.dom.MethodInvocation;
 import org.eclipse.jdt.core.dom.Name;
 import org.eclipse.jdt.core.dom.NameQualifiedType;
+import org.eclipse.jdt.core.dom.NullLiteral;
+import org.eclipse.jdt.core.dom.NumberLiteral;
 import org.eclipse.jdt.core.dom.PackageDeclaration;
 import org.eclipse.jdt.core.dom.ParameterizedType;
 import org.eclipse.jdt.core.dom.QualifiedName;
@@ -49,6 +54,7 @@
 import org.eclipse.jdt.core.dom.SuperMethodReference;
 import org.eclipse.jdt.core.dom.Type;
 import org.eclipse.jdt.core.dom.TypeDeclaration;
+import org.eclipse.jdt.core.dom.TypeLiteral;
 import org.eclipse.jdt.core.dom.TypeParameter;
 import org.eclipse.jdt.core.dom.UnionType;
 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
@@ -316,4 +322,35 @@ public boolean visit(MemberValuePair node) {
 		return true;
 	}
 
+	// following ones are for values in SingleMemberAnnotation
+	@Override
+	public boolean visit(NumberLiteral node) {
+		defaultVisitImplementation(node, (x,y) -> y.match(node, this.nodeSet, this.locator));
+		return true;
+	}
+	@Override
+	public boolean visit(CharacterLiteral node) {
+		defaultVisitImplementation(node, (x,y) -> y.match(node, this.nodeSet, this.locator));
+		return true;
+	}
+	@Override
+	public boolean visit(BooleanLiteral node) {
+		defaultVisitImplementation(node, (x,y) -> y.match(node, this.nodeSet, this.locator));
+		return true;
+	}
+	@Override
+	public boolean visit(ArrayInitializer node) {
+		defaultVisitImplementation(node, (x,y) -> y.match(node, this.nodeSet, this.locator));
+		return true;
+	}
+	@Override
+	public boolean visit(TypeLiteral node) {
+		defaultVisitImplementation(node, (x,y) -> y.match(node, this.nodeSet, this.locator));
+		return true;
+	}
+	@Override
+	public boolean visit(NullLiteral node) {
+		defaultVisitImplementation(node, (x,y) -> y.match(node, this.nodeSet, this.locator));
+		return true;
+	}
 }

org.eclipse.jdt.core.javac/src/org/eclipse/jdt/internal/core/search/matching/DOMMethodLocator.java

@@ -130,7 +130,6 @@ public LocatorResponse match(Annotation node, NodeSetWrapper nodeSet, MatchLocat
 			POSSIBLE_MATCH : IMPOSSIBLE_MATCH);
 	}
 
-
 	private int matchReference(SimpleName name, List<?> args) {
 		if (!this.locator.pattern.findReferences) return IMPOSSIBLE_MATCH;
 
@@ -151,14 +150,21 @@ public LocatorResponse match(MethodInvocation node, NodeSetWrapper nodeSet, Matc
 	}
 	@Override
 	public LocatorResponse match(org.eclipse.jdt.core.dom.Expression expression, NodeSetWrapper nodeSet, MatchLocator locator) {
-		int level = expression instanceof SuperMethodInvocation node ? this.matchReference(node.getName(), node.arguments()) :
-			IMPOSSIBLE_MATCH;
+		int level = IMPOSSIBLE_MATCH;
+		if (expression instanceof SuperMethodInvocation node) {
+			level = this.matchReference(node.getName(), node.arguments());
+		}
+		if (expression.getLocationInParent() == SingleMemberAnnotation.VALUE_PROPERTY
+			&& this.locator.pattern.matchesName(this.locator.pattern.selector, "value".toCharArray())
+			&& this.locator.pattern.parameterCount == 0) {
+			// TODO: also check annotation name matches pattern (if available)
+			level = POSSIBLE_MATCH;
+		}
 		if( level == IMPOSSIBLE_MATCH)
 			return toResponse(IMPOSSIBLE_MATCH);
 		return toResponse(nodeSet.addMatch(expression, level), true);
 	}
 
-
 	@Override
 	public LocatorResponse match(Name node, NodeSetWrapper nodeSet, MatchLocator locator) {
 		if( node.getParent() instanceof MethodInvocation mi && mi.getName() == node) {
@@ -447,7 +453,8 @@ public LocatorResponse resolveLevel(org.eclipse.jdt.core.dom.ASTNode node, IBind
 		boolean isErasurePattern = isPatternErasureMatch();
 		boolean isEquivPattern = isPatternEquivalentMatch();
 
-		if (node instanceof SingleMemberAnnotation singleMemberAnnotation) {
+		if (node.getLocationInParent() == SingleMemberAnnotation.VALUE_PROPERTY
+			&& node.getParent() instanceof SingleMemberAnnotation singleMemberAnnotation) {
 			var valuePairs = singleMemberAnnotation.resolveAnnotationBinding().getDeclaredMemberValuePairs();
 			if (valuePairs != null && valuePairs.length > 0) {
 				binding = valuePairs[0].getMethodBinding();