Merge remote-tracking branch 'origin/master' into BETA_JAVA26

Author: mpalat

org.eclipse.jdt.apt.pluggable.core/META-INF/MANIFEST.MF

@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.apt.pluggable.core;singleton:=true
-Bundle-Version: 1.4.600.qualifier
+Bundle-Version: 1.4.700.qualifier
 Bundle-Activator: org.eclipse.jdt.internal.apt.pluggable.core.Apt6Plugin
 Bundle-Vendor: %providerName
 Require-Bundle: org.eclipse.core.runtime,

org.eclipse.jdt.apt.pluggable.core/src/org/eclipse/jdt/internal/apt/pluggable/core/dispatch/IdeProcessingEnvImpl.java

@@ -102,7 +102,7 @@ public Map<String, String> getOptions() {
 
 	private Function<Entry<String, String>, String> replacePlaceholdersUsing(Map<String, String> commandLineOptions) {
 		return option -> {
-			String variable, replacement, optionValue = option.getValue();
+			String variable, replacement, optionValue = option.getValue() == null ? "" : option.getValue();
 			Matcher placeholder = Pattern.compile("%([^%]+)%").matcher(optionValue);
 			if (placeholder.find() && (variable = placeholder.group(1)) != null
 					&& (replacement = commandLineOptions.get(variable)) != null) {

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

@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.apt.pluggable.tests;singleton:=true
-Bundle-Version: 3.6.800.qualifier
+Bundle-Version: 3.6.900.qualifier
 Bundle-Activator: org.eclipse.jdt.apt.pluggable.tests.Apt6TestsPlugin
 Bundle-Localization: plugin
 Require-Bundle: org.junit,

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

@@ -19,7 +19,7 @@
     <relativePath>../tests-pom/</relativePath>
   </parent>
   <artifactId>org.eclipse.jdt.apt.pluggable.tests</artifactId>
-  <version>3.6.800-SNAPSHOT</version>
+  <version>3.6.900-SNAPSHOT</version>
   <packaging>eclipse-test-plugin</packaging>
   <properties>
   	<testSuite>${project.artifactId}</testSuite>

org.eclipse.jdt.apt.pluggable.tests/src/org/eclipse/jdt/apt/pluggable/tests/BuilderTests.java

@@ -415,6 +415,25 @@ public void testBug341298() throws Throwable {
 		fullBuild();
 		assertTrue("Processor should be able to compile with passed options", Bug341298Processor.success());
 	}
+	public void testGHIssue4640() throws Throwable {
+		ProcessorTestStatus.reset();
+		IJavaProject project = createJavaProject(_projectName);
+		IPath root = project.getProject().getFullPath().append("src");
+		env.addClass(root, "test341298", "Annotated",
+				"package test341298;\n" +
+				"@Annotation public class Annotated {}"
+		);
+		env.addClass(root, "test341298", "Annotation",
+				"package test341298;\n" +
+				"public @interface Annotation {}"
+		);
+		AptConfig.addProcessorOption(project, "classpath", "%classpath%");
+		AptConfig.addProcessorOption(project, "sourcepath", "%sourcepath%");
+		AptConfig.addProcessorOption(project, "phase", null);
+		AptConfig.setEnabled(project, true);
+		fullBuild();
+		assertTrue("Processor should be able to compile with passed options", Bug341298Processor.success());
+	}
 
 	public void testBug539663() throws Throwable {
 		if (!canRunJava9()) {

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/Annotation.java

@@ -1377,6 +1377,8 @@ public static void isTypeUseCompatible(TypeReference reference, Scope scope, Ann
 
 		nextAnnotation:
 			for (Annotation annotation : annotations) {
+				if (annotation.resolvedType == null) // barked elsewhere or still cooking and we come here due to re-entrancy
+					continue;
 				long metaTagBits = annotation.resolvedType.getAnnotationTagBits();
 				if ((metaTagBits & TagBits.AnnotationForTypeUse) != 0 && (metaTagBits & TagBits.AnnotationForDeclarationMASK) == 0) {
 					ReferenceBinding currentType = (ReferenceBinding) resolvedType;

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/FunctionalExpression.java

@@ -239,6 +239,8 @@ public VisibilityInspector(FunctionalExpression expression, Scope scope, boolean
 		}
 
 		private void checkVisibility(ReferenceBinding referenceBinding) {
+			if (referenceBinding.isUnresolvedType())
+				referenceBinding = (ReferenceBinding) BinaryTypeBinding.resolveType(referenceBinding, this.scope.environment(), false);
 			if (!referenceBinding.canBeSeenBy(this.scope)) {
 				this.visible = false;
 				if (this.shouldChatter)

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/RecordPattern.java

@@ -128,12 +128,13 @@ public TypeBinding resolveType(BlockScope scope) {
 			}
 		}
 
+		RecordComponentBinding[] componentBindings = this.resolvedType.components();
 		LocalVariableBinding [] bindings = NO_VARIABLES;
 		for (int i = 0, l = this.patterns.length; i < l; ++i) {
 			Pattern p = this.patterns[i];
+			p.setOuterExpressionType(componentBindings[i].type);
 			p.resolveTypeWithBindings(bindings, scope);
 			bindings = LocalVariableBinding.merge(bindings, p.bindingsWhenTrue());
-			p.setOuterExpressionType(this.resolvedType.components()[i].type);
 		}
 
 		if (this.resolvedType == null || !this.resolvedType.isValidBinding()) {

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

@@ -1387,9 +1387,9 @@ void buildComponents() {
 
 	void connectTypeHierarchy() {
 		SourceTypeBinding sourceType = this.referenceContext.binding;
+		boolean previousFlag = environment().enterSuperTypeLookup(sourceType);
 		if ((sourceType.tagBits & TagBits.BeginHierarchyCheck) == 0) {
 			sourceType.tagBits |= TagBits.BeginHierarchyCheck;
-			environment().typesBeingConnected.add(sourceType);
 			boolean noProblems = connectSuperclass();
 			noProblems &= connectSuperInterfaces();
 			if ((sourceType.typeBits & (TypeIds.BitAutoCloseable|TypeIds.BitCloseable)) != 0) {
@@ -1412,6 +1412,7 @@ void connectTypeHierarchy() {
 			throw e;
 		} finally {
 			env.missingClassFileLocation = null;
+			env.root.isResolvingSuperType = previousFlag;
 		}
 	}
 
@@ -1429,17 +1430,20 @@ private void connectTypeHierarchyWithoutMembers() {
 		SourceTypeBinding sourceType = this.referenceContext.binding;
 		if ((sourceType.tagBits & TagBits.BeginHierarchyCheck) != 0)
 			return;
-
-		sourceType.tagBits |= TagBits.BeginHierarchyCheck;
-		environment().typesBeingConnected.add(sourceType);
-		boolean noProblems = connectSuperclass();
-		noProblems &= connectSuperInterfaces();
-		environment().typesBeingConnected.remove(sourceType);
-		sourceType.tagBits |= TagBits.EndHierarchyCheck;
-		noProblems &= connectTypeVariables(this.referenceContext.typeParameters, false);
-		sourceType.tagBits |= TagBits.TypeVariablesAreConnected;
-		if (noProblems && sourceType.isHierarchyInconsistent())
-			problemReporter().hierarchyHasProblems(sourceType);
+		boolean previousFlag = environment().enterSuperTypeLookup(sourceType);
+		try {
+			sourceType.tagBits |= TagBits.BeginHierarchyCheck;
+			boolean noProblems = connectSuperclass();
+			noProblems &= connectSuperInterfaces();
+			environment().typesBeingConnected.remove(sourceType);
+			sourceType.tagBits |= TagBits.EndHierarchyCheck;
+			noProblems &= connectTypeVariables(this.referenceContext.typeParameters, false);
+			sourceType.tagBits |= TagBits.TypeVariablesAreConnected;
+			if (noProblems && sourceType.isHierarchyInconsistent())
+				problemReporter().hierarchyHasProblems(sourceType);
+		} finally {
+			environment().root.isResolvingSuperType = previousFlag;
+		}
 	}
 
 	public boolean detectHierarchyCycle(TypeBinding superType, TypeReference reference) {

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

@@ -125,6 +125,7 @@ public class LookupEnvironment implements ProblemReasons, TypeConstants {
 	private ArrayList<MissingTypeBinding> missingTypes;
 	final Set<SourceTypeBinding> typesBeingConnected;	// SHARED
 	public boolean isProcessingAnnotations = false; // ROOT_ONLY
+	public boolean isResolvingSuperType = false; // ROOT_ONLY
 	public boolean mayTolerateMissingType = false;
 
 	AnnotationBinding nonNullAnnotation;
@@ -154,21 +155,34 @@ public class LookupEnvironment implements ProblemReasons, TypeConstants {
 	static class GlobalDataMemento {
 		Set<SourceTypeBinding> typesBeingConnected;
 		boolean mayTolerateMissingType = false;
-		GlobalDataMemento(Set<SourceTypeBinding> typesBeingConnected, boolean mayTolerateMissingType) {
+		boolean isResolvingSuperType = false;
+		GlobalDataMemento(Set<SourceTypeBinding> typesBeingConnected, boolean mayTolerateMissingType, boolean isResolvingSuperType) {
 			this.typesBeingConnected = typesBeingConnected;
 			this.mayTolerateMissingType = mayTolerateMissingType;
+			this.isResolvingSuperType = isResolvingSuperType;
 		}
 	}
 	GlobalDataMemento stashGlobalData() {
-		GlobalDataMemento memento = new GlobalDataMemento(new LinkedHashSet<>(this.typesBeingConnected), this.mayTolerateMissingType);
-		this.typesBeingConnected.clear();
+		GlobalDataMemento memento = new GlobalDataMemento(new LinkedHashSet<>(this.typesBeingConnected),
+				this.mayTolerateMissingType, this.root.isResolvingSuperType);
+		if (!this.root.isResolvingSuperType)
+			this.typesBeingConnected.clear(); // lookup is not within the hierarchy of these types
+		this.root.isResolvingSuperType = false;
 		this.mayTolerateMissingType = false;
 		return memento;
 	}
 	void restoreFrom(GlobalDataMemento memento) {
 		this.typesBeingConnected.clear();
 		this.typesBeingConnected.addAll(memento.typesBeingConnected);
 		this.mayTolerateMissingType = memento.mayTolerateMissingType;
+		this.root.isResolvingSuperType = memento.isResolvingSuperType;
+	}
+
+	public boolean enterSuperTypeLookup(SourceTypeBinding sourceType) {
+		this.typesBeingConnected.add(sourceType);
+		boolean previous = this.root.isResolvingSuperType;
+		this.root.isResolvingSuperType = true;
+		return previous;
 	}
 
 	static enum CompleteTypeBindingsSteps {