feat(Compiler): Add file removal tracking in watch-run

-Closes 5072.

Author: cacheflow

lib/Compiler.js

@@ -128,6 +128,7 @@ class Compiler extends Tapable {
 		/** @type {string|null} */
 		this.recordsOutputPath = null;
 		this.records = {};
+		this.removedFiles = new Set();
 		/** @type {Map<string, number>} */
 		this.fileTimestamps = new Map();
 		/** @type {Map<string, number>} */
@@ -192,6 +193,7 @@ class Compiler extends Tapable {
 		this.running = true;
 		this.fileTimestamps = new Map();
 		this.contextTimestamps = new Map();
+		this.removedFiles = new Set();
 		return new Watching(this, watchOptions, handler);
 	}
 
@@ -299,7 +301,6 @@ class Compiler extends Tapable {
 
 	emitAssets(compilation, callback) {
 		let outputPath;
-
 		const emitFiles = err => {
 			if (err) return callback(err);
 

lib/WatchIgnorePlugin.js

@@ -38,10 +38,10 @@ class IgnoringWatchFileSystem {
 				dirsModified,
 				missingModified,
 				fileTimestamps,
-				dirTimestamps
+				dirTimestamps,
+				removedFiles
 			) => {
 				if (err) return callback(err);
-
 				for (const path of ignoredFiles) {
 					fileTimestamps.set(path, 1);
 				}
@@ -56,7 +56,8 @@ class IgnoringWatchFileSystem {
 					dirsModified,
 					missingModified,
 					fileTimestamps,
-					dirTimestamps
+					dirTimestamps,
+					removedFiles
 				);
 			},
 			callbackUndelayed

lib/Watching.js

@@ -50,7 +50,6 @@ class Watching {
 				this.compiler.emitAssets(compilation, err => {
 					if (err) return this._done(err);
 					if (this.invalid) return this._done();
-
 					this.compiler.emitRecords(err => {
 						if (err) return this._done(err);
 
@@ -95,7 +94,6 @@ class Watching {
 			this.handler(err, stats);
 			return;
 		}
-
 		this.compiler.hooks.done.callAsync(stats, () => {
 			this.handler(null, stats);
 			if (!this.closed) {
@@ -124,7 +122,8 @@ class Watching {
 				contextModified,
 				missingModified,
 				fileTimestamps,
-				contextTimestamps
+				contextTimestamps,
+				removedFiles
 			) => {
 				this.pausedWatcher = this.watcher;
 				this.watcher = null;
@@ -133,6 +132,7 @@ class Watching {
 				}
 				this.compiler.fileTimestamps = fileTimestamps;
 				this.compiler.contextTimestamps = contextTimestamps;
+				this.compiler.removedFiles = removedFiles;
 				this._invalidate();
 			},
 			(fileName, changeTime) => {

lib/node/NodeWatchFileSystem.js

@@ -44,24 +44,34 @@ class NodeWatchFileSystem {
 		if (callbackUndelayed) {
 			this.watcher.once("change", callbackUndelayed);
 		}
-
+		const cachedFiles = files;
+		const cachedDirs = dirs;
 		this.watcher.once("aggregated", (changes, removals) => {
 			changes = changes.concat(removals);
 			if (this.inputFileSystem && this.inputFileSystem.purge) {
 				this.inputFileSystem.purge(changes);
 			}
 			const times = objectToMap(this.watcher.getTimes());
+			files = new Set(files);
+			dirs = new Set(dirs);
+			missing = new Set(missing);
+			removals = new Set(removals.filter(file => files.has(file)));
 			callback(
 				null,
-				changes.filter(file => files.includes(file)).sort(),
-				changes.filter(file => dirs.includes(file)).sort(),
-				changes.filter(file => missing.includes(file)).sort(),
+				changes.filter(file => files.has(file)).sort(),
+				changes.filter(file => dirs.has(file)).sort(),
+				changes.filter(file => missing.has(file)).sort(),
+				times,
 				times,
-				times
+				removals
 			);
 		});
 
-		this.watcher.watch(files.concat(missing), dirs.concat(missing), startTime);
+		this.watcher.watch(
+			cachedFiles.concat(missing),
+			cachedDirs.concat(missing),
+			startTime
+		);
 
 		if (oldWatcher) {
 			oldWatcher.close();

test/RemoveFiles.test.js

@@ -0,0 +1,135 @@
+"use strict";
+
+/* globals describe it */
+const path = require("path");
+const MemoryFs = require("memory-fs");
+const webpack = require("../");
+const fs = require("fs");
+const rimraf = require("rimraf");
+
+const createCompiler = config => {
+	const compiler = webpack(config);
+	compiler.outputFileSystem = new MemoryFs();
+	return compiler;
+};
+
+const tempFolderPath = path.join(__dirname, "temp");
+const tempFilePath = path.join(tempFolderPath, "temp-file.js");
+const tempFile2Path = path.join(tempFolderPath, "temp-file2.js");
+
+const createSingleCompiler = () => {
+	return createCompiler({
+		entry: tempFilePath,
+		watch: true,
+		output: {
+			path: tempFolderPath,
+			filename: "bundle.js"
+		}
+	});
+};
+
+describe("RemovedFiles", () => {
+	jest.setTimeout(20000);
+
+	function cleanup() {
+		rimraf.sync(tempFolderPath);
+	}
+
+	beforeAll(() => {
+		cleanup();
+		fs.mkdirSync(tempFolderPath);
+		fs.writeFileSync(
+			tempFilePath,
+			"module.exports = function temp() {return 'temp file';};\n require('./temp-file2')",
+			"utf-8"
+		);
+		fs.writeFileSync(
+			tempFile2Path,
+			"module.exports = function temp2() {return 'temp file 2';};",
+			"utf-8"
+		);
+	});
+	afterAll(done => {
+		cleanup();
+		done();
+	});
+
+	it("should track removed files when they've been deleted in watchRun", done => {
+		const compiler = createSingleCompiler();
+		let watcher;
+		function handleError(err) {
+			if (err) done(err);
+		}
+		setTimeout(() => {
+			fs.unlinkSync(tempFilePath, handleError);
+		}, 2000);
+		compiler.hooks.watchRun.tap("RemovedFilesTest", (compiler, err) => {
+			if (err) {
+				done(err);
+			}
+			const removals = Array.from(compiler.removedFiles);
+			if (removals.length > 0) {
+				setTimeout(() => {
+					expect(removals).toContain(tempFilePath);
+					watcher.close();
+					done();
+				}, 100);
+			}
+		});
+
+		watcher = compiler.watch(
+			{
+				aggregateTimeout: 50
+			},
+			(err, stats) => {}
+		);
+	});
+
+	it("should not track removed files when they have not been deleted in watchRun", done => {
+		const compiler = createSingleCompiler();
+		let watcher;
+		compiler.hooks.watchRun.tap("RemovedFilesTest", (compiler, err) => {
+			if (err) {
+				done(err);
+			}
+			expect(Array.from(compiler.removedFiles)).toHaveLength(0);
+			done();
+			watcher.close();
+		});
+
+		watcher = compiler.watch(
+			{
+				aggregateTimeout: 50
+			},
+			(err, stats) => {}
+		);
+	});
+
+	it("should not track removed files when files have been modified", done => {
+		const compiler = createSingleCompiler();
+		let watcher;
+		function handleError(err) {
+			if (err) done(err);
+		}
+		let updateFile = () => {
+			fs.writeFile(tempFile2Path, "hello world", "utf-8", handleError);
+		};
+		updateFile();
+		compiler.hooks.watchRun.tap("RemovedFilesTest", (compiler, err) => {
+			handleError(err);
+			setTimeout(() => {
+				expect(Array.from(compiler.removedFiles)).toHaveLength(0);
+				watcher.close();
+				done();
+			}, 500);
+			watcher.close();
+		});
+
+		watcher = compiler.watch(
+			{
+				aggregateTimeout: 50
+			},
+			(err, stats) => {}
+		);
+	});
+});