ecj doesn't properly apply the comb rule from 15.12.1 (eclipse-jdt#4087)

+ don't find private methods from super types
  + unless there is only one private method, to be reported as invisible

+ support running with run.javac on JDK 24.0.1

Fixes eclipse-jdt#4081

Author: stephan-herrmann

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

@@ -1684,6 +1684,9 @@ public MethodBinding findMethod0(ReferenceBinding receiverType, char[] selector,
 		// superclass lookup
 		ReferenceBinding classHierarchyStart = currentType;
 		MethodVerifier verifier = environment().methodVerifier();
+		boolean currentIsSuper = false;
+		MethodBinding singlePrivateMethod = null;
+		boolean multiplePrivateMethods = false;
 		while (currentType != null) {
 			unitScope.recordTypeReference(currentType);
 			currentType = (ReferenceBinding) currentType.capture(this, invocationSite == null ? 0 : invocationSite.sourceStart(), invocationSite == null ? 0 : invocationSite.sourceEnd());
@@ -1721,18 +1724,29 @@ public MethodBinding findMethod0(ReferenceBinding receiverType, char[] selector,
 				}
 
 				if (currentLength > 0) {
-					// append currentMethods, filtering out null entries
-					if (currentMethods.length == currentLength) {
+					// append currentMethods, filtering out null entries and private super methods
+					if (currentMethods.length == currentLength && !currentIsSuper) {
 						found.addAll(currentMethods);
 					} else {
 						for (MethodBinding currentMethod : currentMethods) {
-							if (currentMethod != null)
-								found.add(currentMethod);
+							if (currentMethod != null) {
+								if (currentIsSuper && currentMethod.isPrivate()) {
+									if (singlePrivateMethod == null && !multiplePrivateMethods) {
+										singlePrivateMethod = currentMethod;
+									} else {
+										singlePrivateMethod = null;
+										multiplePrivateMethods = true;
+									}
+								} else {
+									found.add(currentMethod);
+								}
+							}
 						}
 					}
 				}
 			}
 			currentType = currentType.superclass();
+			currentIsSuper = true;
 		}
 
 		// if found several candidates, then eliminate those not matching argument types
@@ -1772,6 +1786,9 @@ public MethodBinding findMethod0(ReferenceBinding receiverType, char[] selector,
 					case ProblemReasons.TypeParameterArityMismatch :
 						return problemMethod;
 				}
+			} else if (foundSize == 0 && singlePrivateMethod != null) {
+				// if there is only one private method, we want to report that it is not visible.
+				return new ProblemMethodBinding(singlePrivateMethod, selector, singlePrivateMethod.parameters, ProblemReasons.NotVisible);
 			}
 			// abstract classes may get a match in interfaces; for non abstract
 			// classes, reduces secondary errors since missing interface method

org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/AbstractRegressionTest.java

@@ -575,6 +575,8 @@ static int minorFromRawVersion (String version, String rawVersion) {
 			switch(rawVersion) {
 				case "24-ea", "24-beta", "24":
 					return 0000;
+				case "24.0.1":
+					return 0100;
 			}
 		}
 		throw new RuntimeException("unknown raw javac version: " + rawVersion);

org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/InnerEmulationTest.java

@@ -5994,31 +5994,118 @@ public void test172() throws Exception {
 		this.runNegativeTest(
 				files,
 				"----------\n" +
-				"1. WARNING in X.java (at line 8)\n" +
+				"1. ERROR in X.java (at line 8)\n" +
 				"	a(null);\n" +
-				"	^^^^^^^\n" +
-				"Access to enclosing method a(String) from the type X is emulated by a synthetic accessor method\n" +
-				"----------\n" +
-				"2. WARNING in X.java (at line 9)\n" +
-				"	c(null);\n" +
-				"	^^^^^^^\n" +
-				"Access to enclosing method c(String) from the type X is emulated by a synthetic accessor method\n" +
+				"	^\n" +
+				"The method a() in the type X is not applicable for the arguments (null)\n" +
 				"----------\n" +
-				"3. WARNING in X.java (at line 14)\n" +
+				"2. WARNING in X.java (at line 14)\n" +
 				"	a(null);\n" +
 				"	^^^^^^^\n" +
 				"Access to enclosing method a(String) from the type X is emulated by a synthetic accessor method\n" +
 				"----------\n" +
-				"4. WARNING in X.java (at line 15)\n" +
+				"3. WARNING in X.java (at line 15)\n" +
 				"	c(null);\n" +
 				"	^^^^^^^\n" +
 				"Access to enclosing method c(String) from the type X is emulated by a synthetic accessor method\n" +
 				"----------\n"
 				);
 	} else {
-		this.runConformTest(files, "");
+		this.runNegativeTest(files,
+				"----------\n" +
+				"1. ERROR in X.java (at line 8)\n" +
+				"	a(null);\n" +
+				"	^\n" +
+				"The method a() in the type X is not applicable for the arguments (null)\n" +
+				"----------\n");
 	}
 }
+public void test172b() throws Exception {
+	runNegativeTest(new String[] {
+			"X.java",
+			"""
+			class Y {
+				void a() { }
+				private static void a(String s) { }
+
+				public static class X extends Y {
+
+					void a(int x, int y) { }
+					private void c() { }
+					private static void c(String s) { }
+
+					static class M1 extends X {
+						public void x() {
+							a(null);
+							c(null);
+						}
+					}
+
+					static class M2 {
+						public void x() {
+							a(null);
+							c(null);
+						}
+					}
+				}
+			}
+			"""
+		},
+		"""
+		----------
+		1. ERROR in X.java (at line 13)
+			a(null);
+			^
+		The method a(int, int) in the type Y.X is not applicable for the arguments (null)
+		----------
+		2. ERROR in X.java (at line 20)
+			a(null);
+			^
+		The method a(int, int) in the type Y.X is not applicable for the arguments (null)
+		----------
+		""");
+}
+public void test172c() throws Exception {
+	runNegativeTest(new String[] {
+			"Test.java",
+			"""
+			class Super {
+			    void f2(String s)       {}
+			    void f3(String s)       {}
+			    void f3(int i1, int i2) {}
+			}
+
+			class Test {
+			    void f1(int i) {}
+			    void f2(int i) {}
+			    void f3(int i) {}
+
+			    void m() {
+			        new Super() {
+			            {
+			                f1(0);  // OK, resolves to Test.f1(int)
+			                f2(0);  // compile-time error
+			                f3(0);  // compile-time error
+			            }
+			        };
+			    }
+			}
+			"""
+		},
+		"""
+		----------
+		1. ERROR in Test.java (at line 16)
+			f2(0);  // compile-time error
+			^^
+		The method f2(String) in the type Super is not applicable for the arguments (int)
+		----------
+		2. ERROR in Test.java (at line 17)
+			f3(0);  // compile-time error
+			^^
+		The method f3(int, int) in the type Super is not applicable for the arguments (int)
+		----------
+		""");
+}
 //https://bugs.eclipse.org/bugs/show_bug.cgi?id=308245
 public void test173() throws Exception {
 	this.runConformTest(

org.eclipse.jdt.core.tests.compiler/src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTestForMethod.java

@@ -4130,7 +4130,7 @@ public void test147() {
 				+ "1. ERROR in test\\X.java (at line 6)\n"
 				+ "	* @see Visibility#avm_private(int) Invalid ref: non-applicable inherited method\n"
 				+ "	                  ^^^^^^^^^^^\n"
-				+ "Javadoc: The method avm_private() in the type AbstractVisibility is not applicable for the arguments (int)\n"
+				+ "Javadoc: The method avm_private() from the type AbstractVisibility is not visible\n"
 				+ "----------\n"
 				+ "2. ERROR in test\\X.java (at line 7)\n"
 				+ "	* @see Visibility#avm_public(String) Invalid ref: non-applicable inherited method\n"