Perform a full build if output folder was deleted externally

If the output folder is deleted externally, Java builder doesn't rebuild
anything on next auto / incremental build request.

The change checks the missing output folder on the next build request
and converts build kind to a FULL_BUILD if at least one output folder in
the project is missing.

Fixes #4745

Author: iloveeclipse

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

@@ -1018,24 +1018,52 @@ public void test0100() throws JavaModelException {
 }
 
 // https://bugs.eclipse.org/bugs/show_bug.cgi?id=143025
+// https://github.com/eclipse-jdt/eclipse.jdt.core/issues/4745
 public void testMissingOutputFolder() throws JavaModelException {
 	IPath projectPath = env.addProject("P"); //$NON-NLS-1$
+	IJavaProject p = env.getJavaProject(projectPath);
 	env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
-	env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
+	IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
 	IPath bin = env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
-
+	env.addExternalJars(projectPath, Util.getJavaClassLibs());
+	env.addClass(root, "q", "Y", """
+			package q;
+			public class Y {}
+			""");
 	fullBuild();
 	expectingNoProblems();
+	IPath expectedClassFilePath = bin.append("q").append("Y.class");
+	expectingPresenceOf(new IPath[]{ expectedClassFilePath });
+
+	env.removeFolder(bin);
+	expectingNoPresenceOf(new IPath[]{ expectedClassFilePath });
+
+	incrementalBuild();
+	expectingNoProblems();
+	expectingPresenceOf(bin); // check that bin folder was recreated and is marked as derived
+	if (!env.getProject(projectPath).getFolder("bin").isDerived()) {
+		fail("output folder is not derived");
+	}
+	expectingNoPresenceOf(new IPath[]{ expectedClassFilePath });
+
+	// now enable the (disabled by default) preference and try again
+	p.setOption(JavaCore.CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER, JavaCore.ENABLED);
 
 	env.removeFolder(bin);
+	expectingNoPresenceOf(new IPath[]{ expectedClassFilePath });
 
 	incrementalBuild();
 	expectingNoProblems();
 	expectingPresenceOf(bin); // check that bin folder was recreated and is marked as derived
-	if (!env.getProject(projectPath).getFolder("bin").isDerived())
+	if (!env.getProject(projectPath).getFolder("bin").isDerived()) {
 		fail("output folder is not derived");
+	}
+
+	expectingPresenceOf(new IPath[]{ expectedClassFilePath });
 	env.removeProject(projectPath);
 }
+
+
 @Override
 protected void tearDown() throws Exception {
 	super.tearDown();

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

@@ -28,6 +28,7 @@
 import java.util.Map.Entry;
 import java.util.Set;
 import org.eclipse.core.resources.ICommand;
+import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
@@ -42,6 +43,7 @@
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.IJavaModelMarker;
 import org.eclipse.jdt.core.IJavaModelStatusConstants;
+import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.compiler.CategorizedProblem;
@@ -686,6 +688,11 @@ private int initializeBuilder(int kind, boolean forBuild) throws CoreException {
 			builtProjects = new LinkedHashSet<>();
 		}
 		builtProjects.add(projectName);
+
+		if (kind != CLEAN_BUILD && kind != FULL_BUILD) {
+			// check if we need to switch to full build due to missing output folder(s)
+			kind = checkOutputFolders(this.javaProject, kind);
+		}
 	}
 
 	this.binaryLocationsPerProject = new HashMap<>(3);
@@ -878,6 +885,55 @@ private void recordNewState(State state) {
 	JavaModelManager.getJavaModelManager().setLastBuiltState(this.currentProject, state);
 }
 
+/**
+ * Checks whether all output folders for the given project exist on disk.
+ *
+ * @param project
+ *                    The Java project to check
+ * @return If any output folder is missing, {@link IncrementalProjectBuilder#FULL_BUILD} is returned and original
+ *         <code>buildKind</code> argument otherwise.
+ */
+protected int checkOutputFolders(IJavaProject project, int buildKind) {
+	if (!JavaCore.ENABLED
+			.equals(project.getOption(JavaCore.CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER, true))) {
+		return buildKind;
+	}
+	try {
+		IWorkspaceRoot root = project.getProject().getWorkspace().getRoot();
+		for (IClasspathEntry entry : project.getRawClasspath()) {
+			if (entry.getEntryKind() != IClasspathEntry.CPE_SOURCE) {
+				continue;
+			}
+			IPath outputLocation = entry.getOutputLocation();
+			if (outputLocation != null) {
+				IContainer outputContainer;
+				if(outputLocation.segmentCount() == 1) {
+					outputContainer = project.getProject();
+				} else {
+					outputContainer = root.getFolder(outputLocation);
+				}
+				if (!existsOnDisk(outputContainer)) {
+					return FULL_BUILD;
+				}
+			}
+		}
+	} catch (JavaModelException e) {
+		// If we can't read the classpath, just return the original build kind
+	}
+	return buildKind;
+}
+
+private static boolean existsOnDisk(IContainer defaultOutputLocation) {
+	boolean exists = defaultOutputLocation.exists();
+	// Resource is not present in workspace model
+	if (!exists) {
+		return false;
+	}
+	// check that the folder *really* exists on disk and is a folder
+	IPath location = defaultOutputLocation.getLocation();
+	return location != null && location.toFile().isDirectory();
+}
+
 /**
  * String representation for debugging purposes
  */