Enhance the BuildContext with the discovered annotations

Currently one can only get the information that annotations are present
on a file in a BuildContext / CompilationParticipant but sometimes it is
much more interesting to know if a specific annotation is present so one
don't need to scann files unnecsaryly.

This captures the found low-level annotations and adds a new method
based on this BuildContext.hasAnnotations(String) so that
CompilationParticipant can check fi the file is of any interest for
them.

Fix #674

Author: laeubi

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/CompilationResult.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2017 IBM Corporation and others.
+ * Copyright (c) 2000, 2023 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -10,9 +10,11 @@
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
+ *     Christoph Läubrich -  Enhance the BuildContext with the discovered annotations #674
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler;
 
+import java.util.ArrayList;
 /**
  * A compilation result consists of all information returned by the compiler for
  * a single compiled compilation source unit.  This includes:
@@ -39,6 +41,7 @@
 import java.util.HashSet;
 import java.util.Hashtable;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
@@ -48,6 +51,7 @@
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 import org.eclipse.jdt.internal.compiler.impl.ReferenceContext;
+import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
 import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
 import org.eclipse.jdt.internal.compiler.parser.RecoveryScannerData;
@@ -81,6 +85,7 @@ public class CompilationResult {
 	public boolean checkSecondaryTypes = false; // check for secondary types which were created after the initial buildTypeBindings call
 	private int numberOfErrors;
 	private boolean hasMandatoryErrors;
+	public List<AnnotationBinding[]> annotations = new ArrayList<>(1);
 
 	private static final int[] EMPTY_LINE_ENDS = Util.EMPTY_INT_ARRAY;
 	private static final Comparator PROBLEM_COMPARATOR = new Comparator() {

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java

@@ -50,6 +50,8 @@
  *                          	Bug 405104 - [1.8][compiler][codegen] Implement support for serializeable lambdas
  *      Sebastian Zarnekow - Contributions for
  *								bug 544921 - [performance] Poor performance with large source files
+ *      Christoph Läubrich - Contributions for
+ *								Issue 674 - Enhance the BuildContext with the discovered annotations
  *******************************************************************************/
 package org.eclipse.jdt.internal.compiler.lookup;
 
@@ -3338,6 +3340,12 @@ SimpleLookupTable storedAnnotations(boolean forceInitialize, boolean forceStore)
 	return this.storedAnnotations;
 }
 
+@Override
+void storeAnnotations(Binding binding, AnnotationBinding[] annotations, boolean forceStore) {
+	super.storeAnnotations(binding, annotations, forceStore);
+	this.scope.referenceCompilationUnit().compilationResult.annotations.add(annotations);
+}
+
 @Override
 public ReferenceBinding superclass() {
 	if (!isPrototype())

org.eclipse.jdt.core.tests.builder/src/org/eclipse/jdt/core/tests/builder/ParticipantBuildTests.java

@@ -378,6 +378,45 @@ public void processAnnotations(BuildContext[] files) {
 		expectingNoProblems();
 	}
 
+	/**
+	 * Test that a build participant can inspect the declared annotations by name
+	 * @throws JavaModelException
+	 */
+	public void testProcessAnnotationHasAnnotation() throws JavaModelException {
+		IPath projectPath = env.addProject("Project", "1.5"); //$NON-NLS-1$ //$NON-NLS-2$
+		env.addExternalJars(projectPath, Util.getJavaClassLibs());
+		env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
+		IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
+		env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
+
+		env.addClass(root, "p1", "Test", //$NON-NLS-1$ //$NON-NLS-2$
+			"package p1;\n" + //$NON-NLS-1$
+			"@GeneratedAnnotation\n" + //$NON-NLS-1$
+			"public class Test { public void method() {  } }\n" //$NON-NLS-1$
+			);
+		env.addClass(root, "p1", "GeneratedAnnotation", //$NON-NLS-1$ //$NON-NLS-2$
+			"package p1;\n" + //$NON-NLS-1$
+			"@interface GeneratedAnnotation{}\n" //$NON-NLS-1$
+			);
+
+		// install compilationParticipant
+		new BuildTestParticipant() {
+			public boolean isAnnotationProcessor() {
+				return true;
+			}
+			public void processAnnotations(BuildContext[] files) {
+				Optional<BuildContext> testFileContext = Arrays.stream(files).filter(bc->bc.getFile().getName().equals("Test.java")).findFirst();
+				assertTrue("Testfile not found in build context!", testFileContext.isPresent());
+				assertTrue(testFileContext.get().hasAnnotations());
+				assertTrue(testFileContext.get().hasAnnotations("p1.GeneratedAnnotation"));
+				assertFalse(testFileContext.get().hasAnnotations("gibts.nicht.Hier"));
+			}
+		};
+
+		fullBuild(projectPath);
+		expectingNoProblems();
+	}
+
 	public void testProcessAnnotationReferences() throws JavaModelException {
 		IPath projectPath = env.addProject("Project", "1.5"); //$NON-NLS-1$ //$NON-NLS-2$
 		env.addExternalJars(projectPath, Util.getJavaClassLibs());

org.eclipse.jdt.core/model/org/eclipse/jdt/core/compiler/BuildContext.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2018 IBM Corporation and others.
+ * Copyright (c) 2006, 2023 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -10,7 +10,7 @@
  *
  * Contributors:
  *    IBM Corporation - initial API and implementation
- *
+ *    Christoph Läubrich -  Enhance the BuildContext with the discovered annotations #674
  *******************************************************************************/
 
 package org.eclipse.jdt.core.compiler;
@@ -60,6 +60,18 @@ public boolean hasAnnotations() {
 	return false; // default overridden by concrete implementation
 }
 
+/**
+ * Returns whether the compilation unit contained any annotations with a given type when it was compiled.
+ *
+ * NOTE: This is only valid during {@link CompilationParticipant#processAnnotations(BuildContext[])}.
+ * @param fqn the fully qualified name of the annotation to check for precence
+ * @return whether the compilation unit contained any annotations of the given type when it was compiled
+ * @since 3.34
+ */
+public boolean hasAnnotations(String fqn) {
+	return false; // default overridden by concrete implementation
+}
+
 /**
  * Record the added/changed generated files that need to be compiled.
  *

org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/AbstractImageBuilder.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2021 IBM Corporation and others.
+ * Copyright (c) 2000, 2023 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -10,6 +10,7 @@
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
+ *     Christoph Läubrich -  Enhance the BuildContext with the discovered annotations #674
  *******************************************************************************/
 package org.eclipse.jdt.internal.core.builder;
 
@@ -23,6 +24,7 @@
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
+import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
 import org.eclipse.jdt.internal.compiler.problem.*;
 import org.eclipse.jdt.internal.compiler.util.SimpleSet;
@@ -60,7 +62,7 @@ public abstract class AbstractImageBuilder implements ICompilerRequestor, ICompi
 private boolean inCompiler;
 
 protected boolean keepStoringProblemMarkers;
-protected Set<SourceFile> filesWithAnnotations = null;
+protected Map<SourceFile, AnnotationBinding[]> filesWithAnnotations = null;
 
 //2000 is best compromise between space used and speed
 public static int MAX_AT_ONCE = Integer.getInteger(JavaModelManager.MAX_COMPILED_UNITS_AT_ONCE, 2000).intValue();
@@ -104,7 +106,7 @@ protected AbstractImageBuilder(JavaBuilder javaBuilder, boolean buildStarting, S
 					// initialize this set so the builder knows to gather CUs that define Annotation types
 					// each Annotation processor participant is then asked to process these files AFTER
 					// the compile loop. The normal dependency loop will then recompile all affected types
-					this.filesWithAnnotations = new HashSet<>(1);
+					this.filesWithAnnotations = new HashMap<>(1);
 					break;
 				}
 			}
@@ -219,8 +221,11 @@ public void acceptResult(CompilationResult result) {
 					createProblemFor(compilationUnit.resource, null, Messages.build_inconsistentClassFile, JavaCore.ERROR);
 			}
 		}
-		if (result.hasAnnotations && this.filesWithAnnotations != null) // only initialized if an annotation processor is attached
-			this.filesWithAnnotations.add(compilationUnit);
+		if (result.hasAnnotations && this.filesWithAnnotations != null) {
+			// only initialized if an annotation processor is attached
+			AnnotationBinding[] bindings = result.annotations.stream().flatMap(Arrays::stream).filter(Objects::nonNull).toArray(AnnotationBinding[]::new);
+			this.filesWithAnnotations.put(compilationUnit, bindings);
+		}
 
 		this.compiler.lookupEnvironment.releaseClassFiles(classFiles);
 		finishedWith(typeLocator, result, compilationUnit.getMainTypeName(), definedTypeNames, duplicateTypeNames);
@@ -653,8 +658,9 @@ protected void processAnnotations(CompilationParticipantResult[] results) {
 	if (!hasAnnotationProcessor) return;
 
 	boolean foundAnnotations = this.filesWithAnnotations != null && this.filesWithAnnotations.size() > 0;
-	for (int i = results.length; --i >= 0;)
-		results[i].reset(foundAnnotations && this.filesWithAnnotations.contains(results[i].sourceFile));
+	for (int i = results.length; --i >= 0;) {
+		results[i].reset(foundAnnotations ? this.filesWithAnnotations.get(results[i].sourceFile) : null);
+	}
 
 	// even if no files have annotations, must still tell every annotation processor in case the file used to have them
 	for (int i = 0, l = this.javaBuilder.participants.length; i < l; i++)

org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/builder/CompilationParticipantResult.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2005, 2018 IBM Corporation and others.
+ * Copyright (c) 2005, 2023 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
@@ -10,17 +10,19 @@
  *
  * Contributors:
  *    IBM - rewrote spec
- *
+ *    Christoph Läubrich -  Enhance the BuildContext with the discovered annotations #674
  *******************************************************************************/
 
 package org.eclipse.jdt.internal.core.builder;
 
 import org.eclipse.core.resources.IFile;
 import org.eclipse.jdt.core.compiler.*;
+import org.eclipse.jdt.internal.compiler.lookup.AnnotationBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 
 public class CompilationParticipantResult extends BuildContext {
 	protected SourceFile sourceFile;
-	protected boolean hasAnnotations; // only set during processAnnotations
+	protected AnnotationBinding[] annotations; // only set during processAnnotations
 	protected IFile[] addedFiles; // added/changed generated source files that need to be compiled
 	protected IFile[] deletedFiles; // previously generated source files that should be deleted
 	protected CategorizedProblem[] problems; // new problems to report against this compilationUnit
@@ -30,7 +32,7 @@ public class CompilationParticipantResult extends BuildContext {
 protected CompilationParticipantResult(SourceFile sourceFile, boolean isTestCode) {
 	this.sourceFile = sourceFile;
 	this.isTestCode = isTestCode;
-	this.hasAnnotations = false;
+	this.annotations = null;
 	this.addedFiles = null;
 	this.deletedFiles = null;
 	this.problems = null;
@@ -66,7 +68,26 @@ public IFile getFile() {
  */
 @Override
 public boolean hasAnnotations() {
-	return this.hasAnnotations; // only set during processAnnotations
+	return this.annotations != null; // only set during processAnnotations
+}
+
+@Override
+public boolean hasAnnotations(String fqn) {
+	if (this.annotations != null) {
+		for (AnnotationBinding binding : this.annotations) {
+			if (binding == null) {
+				continue;
+			}
+			ReferenceBinding type = binding.getAnnotationType();
+			if (type == null || type.compoundName == null) {
+				continue;
+			}
+			if (fqn.equals(new String(CharOperation.concatWith(type.compoundName, '.')))) {
+				return true;
+			}
+		}
+	}
+	return false;
 }
 
 /**
@@ -143,9 +164,9 @@ public void recordNewProblems(CategorizedProblem[] newProblems) {
 	this.problems = merged;
 }
 
-void reset(boolean detectedAnnotations) {
+void reset(AnnotationBinding[] annotations) {
 	// called prior to processAnnotations
-	this.hasAnnotations = detectedAnnotations;
+	this.annotations = annotations;
 	this.addedFiles = null;
 	this.deletedFiles = null;
 	this.problems = null;