Annotation processor regression in 2025-12 #4687 (#4690)

Ensure the method() is invoked and all methods are initialized before being used for both BinaryTypeBinding and SourceTypeBinding.

Author: jarthana

org.eclipse.jdt.compiler.apt.tests/META-INF/MANIFEST.MF

@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.compiler.apt.tests;singleton:=true
-Bundle-Version: 1.3.1000.qualifier
+Bundle-Version: 1.3.1100.qualifier
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
 Bundle-RequiredExecutionEnvironment: JavaSE-21

org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors.jar

@@ -19,7 +19,7 @@
     <relativePath>../tests-pom/</relativePath>
   </parent>
   <artifactId>org.eclipse.jdt.compiler.apt.tests</artifactId>
-  <version>1.3.1000-SNAPSHOT</version>
+  <version>1.3.1100-SNAPSHOT</version>
   <packaging>eclipse-test-plugin</packaging>
 
   <properties>

org.eclipse.jdt.compiler.apt.tests/pom.xml

@@ -0,0 +1,12 @@
+package org.eclipse.jdt.compiler.apt.tests.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Documented
+@Target(ElementType.TYPE)
+public @interface Generated {
+  String from() default "";
+  String generator() default "";
+}

org.eclipse.jdt.compiler.apt.tests/processors/org/eclipse/jdt/compiler/apt/tests/annotations/Generated.java

@@ -0,0 +1,31 @@
+package org.eclipse.jdt.compiler.apt.tests.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+public @interface Value {
+	@Documented
+	@Target(ElementType.TYPE)
+	@interface Immutable {
+
+		boolean singleton() default false;
+
+		boolean intern() default false;
+
+		boolean copy() default true;
+
+		boolean prehash() default false;
+
+		boolean lazyhash() default false;
+
+		boolean builder() default true;
+	}
+	@Target(ElementType.TYPE)
+	@interface Style {
+		String[] get() default "get*";
+		String init() default "*";
+	}
+	@Target(ElementType.TYPE)
+	@interface Builder {}
+}

org.eclipse.jdt.compiler.apt.tests/processors/org/eclipse/jdt/compiler/apt/tests/annotations/Value.java

@@ -17,6 +17,7 @@
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.Writer;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import javax.annotation.processing.AbstractProcessor;
@@ -31,19 +32,25 @@
 import javax.lang.model.element.AnnotationValue;
 import javax.lang.model.element.Element;
 import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.RecordComponentElement;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.util.Elements;
 import javax.tools.Diagnostic;
 import javax.tools.JavaFileObject;
 
-@SupportedAnnotationTypes("org.eclipse.jdt.compiler.apt.tests.annotations.GenClass")
+@SupportedAnnotationTypes({"org.eclipse.jdt.compiler.apt.tests.annotations.GenClass",
+							"org.eclipse.jdt.compiler.apt.tests.annotations.Value.Immutable",
+							"org.eclipse.jdt.compiler.apt.tests.annotations.Value.Style",
+							"org.eclipse.jdt.compiler.apt.tests.annotations.Generated",})		
 @SupportedSourceVersion(SourceVersion.RELEASE_6)
 public class GenClassProc extends AbstractProcessor {
 
 	private Messager _messager;
 	private Filer _filer;
 	private Elements _elementUtil;
 	private TypeElement _annoDecl;
+	private TypeElement _immutableDecl;
+	private TypeElement _styleDecl;
 
 	@Override
 	public synchronized void init(ProcessingEnvironment processingEnv) {
@@ -52,6 +59,8 @@ public synchronized void init(ProcessingEnvironment processingEnv) {
 		_messager = processingEnv.getMessager();
 		_elementUtil = processingEnv.getElementUtils();
 		_annoDecl = _elementUtil.getTypeElement("org.eclipse.jdt.compiler.apt.tests.annotations.GenClass");
+		_immutableDecl = _elementUtil.getTypeElement("org.eclipse.jdt.compiler.apt.tests.annotations.Value.Immutable");
+		_styleDecl = _elementUtil.getTypeElement("org.eclipse.jdt.compiler.apt.tests.annotations.Value.Style");
 
 		//System.out.println("Processor options are: ");
 		//for (Map.Entry<String, String> option : processingEnv.getOptions().entrySet()) {
@@ -62,10 +71,35 @@ public synchronized void init(ProcessingEnvironment processingEnv) {
 	@Override
 	public boolean process(Set<? extends TypeElement> annotations,
 			RoundEnvironment roundEnv) {
-
 		if (annotations == null || annotations.isEmpty()) {
 			return true;
 		}
+		
+		if (annotations.contains(_immutableDecl)) {
+			List<? extends Element> enclosedElements = _styleDecl.getEnclosedElements();
+			int size = enclosedElements.size();
+			if (size > 0) {
+				processGH4687_1();
+				return true;
+			}
+			return false;
+		}
+		if (annotations.contains(_styleDecl)) {
+			Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(_styleDecl);
+			TypeElement brokenRecord = null;
+			for (Element element : elementsAnnotatedWith) {
+				if (element instanceof TypeElement te && te.getSimpleName().toString().equals("BrokenRecord")) {
+					brokenRecord = te;
+					break;
+				}
+			}
+			if (brokenRecord == null) {
+				throw new IllegalArgumentException("TypeElement not found for targets.gh4687.Container.BrokenRecord");
+			}
+			processGH4687_2(brokenRecord);
+			return true;
+		}
+
 		// sanity check
 		if (!annotations.contains(_annoDecl)) {
 			throw new IllegalArgumentException("process() called on an unexpected set of annotations");
@@ -116,7 +150,62 @@ public boolean process(Set<? extends TypeElement> annotations,
 		}
 		return true;
 	}
+	private void processGH4687_1() {
+		createSourceFile1(null, "foobar.ImmutableComp", "toString");
+	}
+	private void processGH4687_2(TypeElement brokenRecord) {
+		List<? extends RecordComponentElement> recordComponents = brokenRecord.getRecordComponents();
+		RecordComponentElement rce = null;
+		for (Element element : recordComponents) {
+			if (element instanceof RecordComponentElement) {
+				rce = (RecordComponentElement) element;
+				break;
+			}
+		}
+		if (rce == null) {
+			throw new IllegalArgumentException("RecordComponentElement not found");
+		}
+		ExecutableElement accessor = rce.getAccessor();
+		if (accessor == null) {
+			throw new IllegalArgumentException("Accessor not found");
+		}
+		createSourceFile2(null, "foobar.WorkingRecordBuilder", "toString");
+	}
 
+	private void createSourceFile1(Element parent, String clazz, String method) {
+		int lastDot = clazz.lastIndexOf('.');
+		if (lastDot <= 0 || clazz.length() == lastDot)
+			return;
+		try {
+			JavaFileObject jfo = _filer.createSourceFile(clazz, parent);
+			String source = """
+					package foobar;
+					public final class ImmutableComp {}
+					""";
+			try (Writer	w = jfo.openWriter(); PrintWriter pw = new PrintWriter(w)) {
+				pw.println(source.toString());
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	private void createSourceFile2(Element parent, String clazz, String method) {
+		int lastDot = clazz.lastIndexOf('.');
+		if (lastDot <= 0 || clazz.length() == lastDot)
+			return;
+		try {
+			JavaFileObject jfo = _filer.createSourceFile(clazz, parent);
+			String source = """
+					package foobar;
+					public final class WorkingRecordBuilder {}
+					""";
+			try (Writer	w = jfo.openWriter(); PrintWriter pw = new PrintWriter(w)) {
+				pw.println(source.toString());
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
 	/**
 	 * Create a source file named 'name', with contents
 	 * that reflect 'method' and 'name'.

org.eclipse.jdt.compiler.apt.tests/processors/org/eclipse/jdt/compiler/apt/tests/processors/genclass/GenClassProc.java

@@ -0,0 +1,8 @@
+package targets.gh4687;
+
+import org.eclipse.jdt.compiler.apt.tests.annotations.Value;
+
+@Value.Immutable
+//@Value.Style
+public class Comp {
+}

org.eclipse.jdt.compiler.apt.tests/resources/targets/gh4687/Comp.java

@@ -0,0 +1,11 @@
+package targets.gh4687;
+import org.eclipse.jdt.compiler.apt.tests.annotations.Value;
+
+interface Container {
+
+	@Value.Style 
+	@Value.Builder
+	public static record BrokenRecord(String member) {
+	}
+
+}

org.eclipse.jdt.compiler.apt.tests/resources/targets/gh4687/Container.java

@@ -118,6 +118,32 @@ public void testCompilerOneClassWithSystemCompiler() throws IOException {
 		internalTestGenerateClass(compiler);
 	}
 
+	/**
+	 * Read annotation values and generate a class using Eclipse compiler
+	 */
+	public void testGhIssue4687WithEclipseCompiler() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		File targetFolder = TestUtils.concatPath(BatchTestUtils.getSrcFolderName(), "targets", "gh4687");
+		File inputFile = BatchTestUtils.copyResource("targets/gh4687/Comp.java", targetFolder);
+		assertNotNull("No input file", inputFile);
+
+		List<String> options = new ArrayList<>();
+		BatchTestUtils.compileOneClass(compiler, options, inputFile);
+
+		// check that the gen-src and class files were generated
+ 		File genSrcFile = TestUtils.concatPath(BatchTestUtils.getGenFolderName(), "foobar", "ImmutableComp.java");
+ 		assertTrue("generated src file does not exist", genSrcFile.exists());
+
+		inputFile = BatchTestUtils.copyResource("targets/gh4687/Container.java", targetFolder);
+		assertNotNull("No input file", inputFile);
+
+		options = new ArrayList<>();
+		BatchTestUtils.compileOneClass(compiler, options, inputFile);
+		// check that the gen-src and class files were generated
+ 		genSrcFile = TestUtils.concatPath(BatchTestUtils.getGenFolderName(), "foobar", "WorkingRecordBuilder.java");
+ 		assertTrue("generated src file does not exist", genSrcFile.exists());
+	}
+	
 	/**
 	 * Read annotation values and generate a class using Eclipse compiler
 	 */

org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/BatchDispatchTests.java

@@ -1771,10 +1771,10 @@ private ReferenceBinding[] maybeSortedMemberTypes() {
  * @return the methods in the original order
  */
 public MethodBinding[] methodsInOriginalOrder() {
-	if (this.methodsInOriginalOrder != null) {
-		return this.methodsInOriginalOrder;
+	if ((this.tagBits & TagBits.AreMethodsComplete) == 0) {
+		methods();
 	}
-	return this.methods;
+	return this.methodsInOriginalOrder == null ? this.methods : this.methodsInOriginalOrder;
 }
 // NOTE: the return type, arg & exception types of each method of a binary type are resolved when needed
 @Override