webpack 5.59.0 → 5.94.0

package/lib/Compiler.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const parseJson = require("json-parse-better-errors");
+const parseJson = require("json-parse-even-better-errors");
 const asyncLib = require("neo-async");
 const {
 	SyncHook,
@@ -14,7 +14,7 @@ const {
 	AsyncSeriesHook
 } = require("tapable");
 const { SizeOnlySource } = require("webpack-sources");
-const webpack = require("./");
+const webpack = require(".");
 const Cache = require("./Cache");
 const CacheFacade = require("./CacheFacade");
 const ChunkGraph = require("./ChunkGraph");
@@ -40,37 +40,54 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Compilation").References} References */
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 /** @typedef {import("./Module")} Module */
-/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */
+/** @typedef {import("./logging/createConsoleLogger").LoggingFunction} LoggingFunction */
+/** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
 /** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
 /**
- * @typedef {Object} CompilationParams
+ * @template {any[]} T
+ * @template V
+ * @typedef {import("./util/WeakTupleMap")<T, V>} WeakTupleMap
+ */
+
+/**
+ * @typedef {object} CompilationParams
  * @property {NormalModuleFactory} normalModuleFactory
  * @property {ContextModuleFactory} contextModuleFactory
  */
 
+/**
+ * @template T
+ * @callback RunCallback
+ * @param {Error | null} err
+ * @param {T=} result
+ */
+
 /**
  * @template T
  * @callback Callback
- * @param {Error=} err
+ * @param {(Error | null)=} err
  * @param {T=} result
  */
 
 /**
  * @callback RunAsChildCallback
- * @param {Error=} err
+ * @param {Error | null} err
  * @param {Chunk[]=} entries
  * @param {Compilation=} compilation
  */
 
 /**
- * @typedef {Object} AssetEmittedInfo
+ * @typedef {object} AssetEmittedInfo
  * @property {Buffer} content
  * @property {Source} source
  * @property {Compilation} compilation
@@ -78,6 +95,9 @@ const { isSourceEqual } = require("./util/source");
  * @property {string} targetPath
  */
 
+/** @typedef {{ sizeOnlySource: SizeOnlySource | undefined, writtenTo: Map<string, number> }} CacheEntry */
+/** @typedef {{ path: string, source: Source, size: number | undefined, waiting: ({ cacheEntry: any, file: string }[] | undefined) }} SimilarEntry */
+
 /**
  * @param {string[]} array an array
  * @returns {boolean} true, if the array is sorted
@@ -90,11 +110,12 @@ const isSorted = array => {
 };
 
 /**
- * @param {Object} obj an object
+ * @param {{[key: string]: any}} obj an object
  * @param {string[]} keys the keys of the object
- * @returns {Object} the object with properties sorted by property name
+ * @returns {{[key: string]: any}} the object with properties sorted by property name
  */
 const sortObject = (obj, keys) => {
+	/** @type {{[key: string]: any}} */
 	const o = {};
 	for (const k of keys.sort()) {
 		o[k] = obj[k];
@@ -111,21 +132,21 @@ const includesHash = (filename, hashes) => {
 	if (!hashes) return false;
 	if (Array.isArray(hashes)) {
 		return hashes.some(hash => filename.includes(hash));
-	} else {
-		return filename.includes(hashes);
 	}
+	return filename.includes(hashes);
 };
 
 class Compiler {
 	/**
 	 * @param {string} context the compilation path
+	 * @param {WebpackOptions} options options
 	 */
-	constructor(context) {
+	constructor(context, options = /** @type {WebpackOptions} */ ({})) {
 		this.hooks = Object.freeze({
 			/** @type {SyncHook<[]>} */
 			initialize: new SyncHook([]),
 
-			/** @type {SyncBailHook<[Compilation], boolean>} */
+			/** @type {SyncBailHook<[Compilation], boolean | undefined>} */
 			shouldEmit: new SyncBailHook(["compilation"]),
 			/** @type {AsyncSeriesHook<[Stats]>} */
 			done: new AsyncSeriesHook(["stats"]),
@@ -164,6 +185,11 @@ class Compiler {
 			/** @type {AsyncSeriesHook<[Compilation]>} */
 			afterCompile: new AsyncSeriesHook(["compilation"]),
 
+			/** @type {AsyncSeriesHook<[]>} */
+			readRecords: new AsyncSeriesHook([]),
+			/** @type {AsyncSeriesHook<[]>} */
+			emitRecords: new AsyncSeriesHook([]),
+
 			/** @type {AsyncSeriesHook<[Compiler]>} */
 			watchRun: new AsyncSeriesHook(["compiler"]),
 			/** @type {SyncHook<[Error]>} */
@@ -175,7 +201,7 @@ class Compiler {
 			/** @type {AsyncSeriesHook<[]>} */
 			shutdown: new AsyncSeriesHook([]),
 
-			/** @type {SyncBailHook<[string, string, any[]], true>} */
+			/** @type {SyncBailHook<[string, string, any[] | undefined], true>} */
 			infrastructureLog: new SyncBailHook(["origin", "type", "args"]),
 
 			// TODO the following hooks are weirdly located here
@@ -194,54 +220,67 @@ class Compiler {
 
 		this.webpack = webpack;
 
-		/** @type {string=} */
+		/** @type {string | undefined} */
 		this.name = undefined;
-		/** @type {Compilation=} */
+		/** @type {Compilation | undefined} */
 		this.parentCompilation = undefined;
 		/** @type {Compiler} */
 		this.root = this;
 		/** @type {string} */
 		this.outputPath = "";
-		/** @type {Watching} */
+		/** @type {Watching | undefined} */
 		this.watching = undefined;
 
-		/** @type {OutputFileSystem} */
+		/** @type {OutputFileSystem | null} */
 		this.outputFileSystem = null;
-		/** @type {IntermediateFileSystem} */
+		/** @type {IntermediateFileSystem | null} */
 		this.intermediateFileSystem = null;
-		/** @type {InputFileSystem} */
+		/** @type {InputFileSystem | null} */
 		this.inputFileSystem = null;
-		/** @type {WatchFileSystem} */
+		/** @type {WatchFileSystem | null} */
 		this.watchFileSystem = null;
 
 		/** @type {string|null} */
 		this.recordsInputPath = null;
 		/** @type {string|null} */
 		this.recordsOutputPath = null;
+		/** @type {Record<string, TODO>} */
 		this.records = {};
 		/** @type {Set<string | RegExp>} */
 		this.managedPaths = new Set();
 		/** @type {Set<string | RegExp>} */
+		this.unmanagedPaths = new Set();
+		/** @type {Set<string | RegExp>} */
 		this.immutablePaths = new Set();
 
-		/** @type {ReadonlySet<string>} */
+		/** @type {ReadonlySet<string> | undefined} */
 		this.modifiedFiles = undefined;
-		/** @type {ReadonlySet<string>} */
+		/** @type {ReadonlySet<string> | undefined} */
 		this.removedFiles = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null> | undefined} */
 		this.fileTimestamps = undefined;
-		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null>} */
+		/** @type {ReadonlyMap<string, FileSystemInfoEntry | "ignore" | null> | undefined} */
 		this.contextTimestamps = undefined;
-		/** @type {number} */
+		/** @type {number | undefined} */
 		this.fsStartTime = undefined;
 
 		/** @type {ResolverFactory} */
 		this.resolverFactory = new ResolverFactory();
 
+		/** @type {LoggingFunction | undefined} */
 		this.infrastructureLogger = undefined;
 
-		/** @type {WebpackOptions} */
-		this.options = /** @type {WebpackOptions} */ ({});
+		/** @type {Readonly<PlatformTargetProperties>} */
+		this.platform = {
+			web: null,
+			browser: null,
+			webworker: null,
+			node: null,
+			nwjs: null,
+			electron: null
+		};
+
+		this.options = options;
 
 		this.context = context;
 
@@ -249,7 +288,7 @@ class Compiler {
 
 		this.cache = new Cache();
 
-		/** @type {Map<Module, { buildInfo: object, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
+		/** @type {Map<Module, { buildInfo: BuildInfo, references: References | undefined, memCache: WeakTupleMap<any, any> }> | undefined} */
 		this.moduleMemCaches = undefined;
 
 		this.compilerPath = "";
@@ -263,16 +302,27 @@ class Compiler {
 		/** @type {boolean} */
 		this.watchMode = false;
 
-		/** @type {Compilation} */
+		this._backCompat = this.options.experiments.backCompat !== false;
+
+		/** @type {Compilation | undefined} */
 		this._lastCompilation = undefined;
-		/** @type {NormalModuleFactory} */
+		/** @type {NormalModuleFactory | undefined} */
 		this._lastNormalModuleFactory = undefined;
 
-		/** @private @type {WeakMap<Source, { sizeOnlySource: SizeOnlySource, writtenTo: Map<string, number> }>} */
+		/**
+		 * @private
+		 * @type {WeakMap<Source, CacheEntry>}
+		 */
 		this._assetEmittingSourceCache = new WeakMap();
-		/** @private @type {Map<string, number>} */
+		/**
+		 * @private
+		 * @type {Map<string, number>}
+		 */
 		this._assetEmittingWrittenFiles = new Map();
-		/** @private @type {Set<string>} */
+		/**
+		 * @private
+		 * @type {Set<string>}
+		 */
 		this._assetEmittingPreviousFiles = new Set();
 	}
 
@@ -308,10 +358,11 @@ class Compiler {
 						);
 					}
 				}
-				if (this.hooks.infrastructureLog.call(name, type, args) === undefined) {
-					if (this.infrastructureLogger !== undefined) {
-						this.infrastructureLogger(name, type, args);
-					}
+				if (
+					this.hooks.infrastructureLog.call(name, type, args) === undefined &&
+					this.infrastructureLogger !== undefined
+				) {
+					this.infrastructureLogger(name, type, args);
 				}
 			},
 			childName => {
@@ -336,36 +387,33 @@ class Compiler {
 							}
 							return `${name}/${childName}`;
 						});
-					} else {
-						return this.getInfrastructureLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
 					}
-				} else {
-					if (typeof childName === "function") {
-						return this.getInfrastructureLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
+					return this.getInfrastructureLogger(() => {
+						if (typeof name === "function") {
+							name = name();
+							if (!name) {
+								throw new TypeError(
+									"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+								);
 							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getInfrastructureLogger(`${name}/${childName}`);
-					}
+						}
+						return `${name}/${childName}`;
+					});
 				}
+				if (typeof childName === "function") {
+					return this.getInfrastructureLogger(() => {
+						if (typeof childName === "function") {
+							childName = childName();
+							if (!childName) {
+								throw new TypeError(
+									"Logger.getChildLogger(name) called with a function not returning a name"
+								);
+							}
+						}
+						return `${name}/${childName}`;
+					});
+				}
+				return this.getInfrastructureLogger(`${name}/${childName}`);
 			}
 		);
 	}
@@ -374,6 +422,17 @@ class Compiler {
 	// e.g. move compilation specific info from Modules into ModuleGraph
 	_cleanupLastCompilation() {
 		if (this._lastCompilation !== undefined) {
+			for (const childCompilation of this._lastCompilation.children) {
+				for (const module of childCompilation.modules) {
+					ChunkGraph.clearChunkGraphForModule(module);
+					ModuleGraph.clearModuleGraphForModule(module);
+					module.cleanupForCache();
+				}
+				for (const chunk of childCompilation.chunks) {
+					ChunkGraph.clearChunkGraphForChunk(chunk);
+				}
+			}
+
 			for (const module of this._lastCompilation.modules) {
 				ChunkGraph.clearChunkGraphForModule(module);
 				ModuleGraph.clearModuleGraphForModule(module);
@@ -396,7 +455,7 @@ class Compiler {
 
 	/**
 	 * @param {WatchOptions} watchOptions the watcher's options
-	 * @param {Callback<Stats>} handler signals when the call finishes
+	 * @param {RunCallback<Stats>} handler signals when the call finishes
 	 * @returns {Watching} a compiler watcher
 	 */
 	watch(watchOptions, handler) {
@@ -411,7 +470,7 @@ class Compiler {
 	}
 
 	/**
-	 * @param {Callback<Stats>} callback signals when the call finishes
+	 * @param {RunCallback<Stats>} callback signals when the call finishes
 	 * @returns {void}
 	 */
 	run(callback) {
@@ -419,8 +478,13 @@ class Compiler {
 			return callback(new ConcurrentCompilationError());
 		}
 
+		/** @type {Logger | undefined} */
 		let logger;
 
+		/**
+		 * @param {Error | null} err error
+		 * @param {Stats=} stats stats
+		 */
 		const finalCallback = (err, stats) => {
 			if (logger) logger.time("beginIdle");
 			this.idle = true;
@@ -432,16 +496,23 @@ class Compiler {
 				this.hooks.failed.call(err);
 			}
 			if (callback !== undefined) callback(err, stats);
-			this.hooks.afterDone.call(stats);
+			this.hooks.afterDone.call(/** @type {Stats} */ (stats));
 		};
 
 		const startTime = Date.now();
 
 		this.running = true;
 
-		const onCompiled = (err, compilation) => {
+		/**
+		 * @param {Error | null} err error
+		 * @param {Compilation=} _compilation compilation
+		 * @returns {void}
+		 */
+		const onCompiled = (err, _compilation) => {
 			if (err) return finalCallback(err);
 
+			const compilation = /** @type {Compilation} */ (_compilation);
+
 			if (this.hooks.shouldEmit.call(compilation) === false) {
 				compilation.startTime = startTime;
 				compilation.endTime = Date.now();
@@ -457,7 +528,8 @@ class Compiler {
 				logger = compilation.getLogger("webpack.Compiler");
 				logger.time("emitAssets");
 				this.emitAssets(compilation, err => {
-					logger.timeEnd("emitAssets");
+					/** @type {Logger} */
+					(logger).timeEnd("emitAssets");
 					if (err) return finalCallback(err);
 
 					if (compilation.hooks.needAdditionalPass.call()) {
@@ -465,10 +537,12 @@ class Compiler {
 
 						compilation.startTime = startTime;
 						compilation.endTime = Date.now();
-						logger.time("done hook");
+						/** @type {Logger} */
+						(logger).time("done hook");
 						const stats = new Stats(compilation);
 						this.hooks.done.callAsync(stats, err => {
-							logger.timeEnd("done hook");
+							/** @type {Logger} */
+							(logger).timeEnd("done hook");
 							if (err) return finalCallback(err);
 
 							this.hooks.additionalPass.callAsync(err => {
@@ -479,17 +553,21 @@ class Compiler {
 						return;
 					}
 
-					logger.time("emitRecords");
+					/** @type {Logger} */
+					(logger).time("emitRecords");
 					this.emitRecords(err => {
-						logger.timeEnd("emitRecords");
+						/** @type {Logger} */
+						(logger).timeEnd("emitRecords");
 						if (err) return finalCallback(err);
 
 						compilation.startTime = startTime;
 						compilation.endTime = Date.now();
-						logger.time("done hook");
+						/** @type {Logger} */
+						(logger).time("done hook");
 						const stats = new Stats(compilation);
 						this.hooks.done.callAsync(stats, err => {
-							logger.timeEnd("done hook");
+							/** @type {Logger} */
+							(logger).timeEnd("done hook");
 							if (err) return finalCallback(err);
 							this.cache.storeBuildDependencies(
 								compilation.buildDependencies,
@@ -538,15 +616,42 @@ class Compiler {
 	 */
 	runAsChild(callback) {
 		const startTime = Date.now();
-		this.compile((err, compilation) => {
-			if (err) return callback(err);
 
-			this.parentCompilation.children.push(compilation);
+		/**
+		 * @param {Error | null} err error
+		 * @param {Chunk[]=} entries entries
+		 * @param {Compilation=} compilation compilation
+		 */
+		const finalCallback = (err, entries, compilation) => {
+			try {
+				callback(err, entries, compilation);
+			} catch (runAsChildErr) {
+				const err = new WebpackError(
+					`compiler.runAsChild callback error: ${runAsChildErr}`
+				);
+				err.details = /** @type {Error} */ (runAsChildErr).stack;
+				/** @type {Compilation} */
+				(this.parentCompilation).errors.push(err);
+			}
+		};
+
+		this.compile((err, _compilation) => {
+			if (err) return finalCallback(err);
+
+			const compilation = /** @type {Compilation} */ (_compilation);
+			const parentCompilation = /** @type {Compilation} */ (
+				this.parentCompilation
+			);
+
+			parentCompilation.children.push(compilation);
+
 			for (const { name, source, info } of compilation.getAssets()) {
-				this.parentCompilation.emitAsset(name, source, info);
+				parentCompilation.emitAsset(name, source, info);
 			}
 
+			/** @type {Chunk[]} */
 			const entries = [];
+
 			for (const ep of compilation.entrypoints.values()) {
 				entries.push(...ep.chunks);
 			}
@@ -554,7 +659,7 @@ class Compiler {
 			compilation.startTime = startTime;
 			compilation.endTime = Date.now();
 
-			return callback(null, entries, compilation);
+			return finalCallback(null, entries, compilation);
 		});
 	}
 
@@ -570,14 +675,19 @@ class Compiler {
 	 * @returns {void}
 	 */
 	emitAssets(compilation, callback) {
+		/** @type {string} */
 		let outputPath;
 
+		/**
+		 * @param {Error=} err error
+		 * @returns {void}
+		 */
 		const emitFiles = err => {
 			if (err) return callback(err);
 
 			const assets = compilation.getAssets();
 			compilation.assets = { ...compilation.assets };
-			/** @type {Map<string, { path: string, source: Source, size: number, waiting: { cacheEntry: any, file: string }[] }>} */
+			/** @type {Map<string, SimilarEntry>} */
 			const caseInsensitiveMap = new Map();
 			/** @type {Set<string>} */
 			const allTargetPaths = new Set();
@@ -589,7 +699,7 @@ class Compiler {
 					let immutable = info.immutable;
 					const queryStringIdx = targetFile.indexOf("?");
 					if (queryStringIdx >= 0) {
-						targetFile = targetFile.substr(0, queryStringIdx);
+						targetFile = targetFile.slice(0, queryStringIdx);
 						// We may remove the hash, which is in the query string
 						// So we recheck if the file is immutable
 						// This doesn't cover all cases, but immutable is only a performance optimization anyway
@@ -601,10 +711,15 @@ class Compiler {
 								includesHash(targetFile, info.fullhash));
 					}
 
+					/**
+					 * @param {Error=} err error
+					 * @returns {void}
+					 */
 					const writeOut = err => {
 						if (err) return callback(err);
 						const targetPath = join(
-							this.outputFileSystem,
+							/** @type {OutputFileSystem} */
+							(this.outputFileSystem),
 							outputPath,
 							targetFile
 						);
@@ -624,6 +739,7 @@ class Compiler {
 							this._assetEmittingSourceCache.set(source, cacheEntry);
 						}
 
+						/** @type {SimilarEntry | undefined} */
 						let similarEntry;
 
 						const checkSimilarFile = () => {
@@ -651,18 +767,17 @@ ${other}`);
 									callback(err);
 								}
 								return true;
-							} else {
-								caseInsensitiveMap.set(
-									caseInsensitiveTargetPath,
-									(similarEntry = {
-										path: targetPath,
-										source,
-										size: undefined,
-										waiting: undefined
-									})
-								);
-								return false;
 							}
+							caseInsensitiveMap.set(
+								caseInsensitiveTargetPath,
+								(similarEntry = /** @type {SimilarEntry} */ ({
+									path: targetPath,
+									source,
+									size: undefined,
+									waiting: undefined
+								}))
+							);
+							return false;
 						};
 
 						/**
@@ -672,14 +787,12 @@ ${other}`);
 						const getContent = () => {
 							if (typeof source.buffer === "function") {
 								return source.buffer();
-							} else {
-								const bufferOrString = source.source();
-								if (Buffer.isBuffer(bufferOrString)) {
-									return bufferOrString;
-								} else {
-									return Buffer.from(bufferOrString, "utf8");
-								}
 							}
+							const bufferOrString = source.source();
+							if (Buffer.isBuffer(bufferOrString)) {
+								return bufferOrString;
+							}
+							return Buffer.from(bufferOrString, "utf8");
 						};
 
 						const alreadyWritten = () => {
@@ -687,9 +800,11 @@ ${other}`);
 							if (targetFileGeneration === undefined) {
 								const newGeneration = 1;
 								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								cacheEntry.writtenTo.set(targetPath, newGeneration);
+								/** @type {CacheEntry} */
+								(cacheEntry).writtenTo.set(targetPath, newGeneration);
 							} else {
-								cacheEntry.writtenTo.set(targetPath, targetFileGeneration);
+								/** @type {CacheEntry} */
+								(cacheEntry).writtenTo.set(targetPath, targetFileGeneration);
 							}
 							callback();
 						};
@@ -700,7 +815,8 @@ ${other}`);
 						 * @returns {void}
 						 */
 						const doWrite = content => {
-							this.outputFileSystem.writeFile(targetPath, content, err => {
+							/** @type {OutputFileSystem} */
+							(this.outputFileSystem).writeFile(targetPath, content, err => {
 								if (err) return callback(err);
 
 								// information marker that the asset has been emitted
@@ -711,7 +827,8 @@ ${other}`);
 									targetFileGeneration === undefined
 										? 1
 										: targetFileGeneration + 1;
-								cacheEntry.writtenTo.set(targetPath, newGeneration);
+								/** @type {CacheEntry} */
+								(cacheEntry).writtenTo.set(targetPath, newGeneration);
 								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
 								this.hooks.assetEmitted.callAsync(
 									file,
@@ -727,16 +844,33 @@ ${other}`);
 							});
 						};
 
+						/**
+						 * @param {number} size size
+						 */
 						const updateWithReplacementSource = size => {
-							updateFileWithReplacementSource(file, cacheEntry, size);
-							similarEntry.size = size;
-							if (similarEntry.waiting !== undefined) {
-								for (const { file, cacheEntry } of similarEntry.waiting) {
+							updateFileWithReplacementSource(
+								file,
+								/** @type {CacheEntry} */ (cacheEntry),
+								size
+							);
+							/** @type {SimilarEntry} */
+							(similarEntry).size = size;
+							if (
+								/** @type {SimilarEntry} */ (similarEntry).waiting !== undefined
+							) {
+								for (const { file, cacheEntry } of /** @type {SimilarEntry} */ (
+									similarEntry
+								).waiting) {
 									updateFileWithReplacementSource(file, cacheEntry, size);
 								}
 							}
 						};
 
+						/**
+						 * @param {string} file file
+						 * @param {CacheEntry} cacheEntry cache entry
+						 * @param {number} size size
+						 */
 						const updateFileWithReplacementSource = (
 							file,
 							cacheEntry,
@@ -753,10 +887,14 @@ ${other}`);
 							});
 						};
 
+						/**
+						 * @param {IStats} stats stats
+						 * @returns {void}
+						 */
 						const processExistingFile = stats => {
 							// skip emitting if it's already there and an immutable file
 							if (immutable) {
-								updateWithReplacementSource(stats.size);
+								updateWithReplacementSource(/** @type {number} */ (stats.size));
 								return alreadyWritten();
 							}
 
@@ -770,19 +908,17 @@ ${other}`);
 							// for a fast negative match file size is compared first
 							if (content.length === stats.size) {
 								compilation.comparedForEmitAssets.add(file);
-								return this.outputFileSystem.readFile(
-									targetPath,
-									(err, existingContent) => {
-										if (
-											err ||
-											!content.equals(/** @type {Buffer} */ (existingContent))
-										) {
-											return doWrite(content);
-										} else {
-											return alreadyWritten();
-										}
+								return /** @type {OutputFileSystem} */ (
+									this.outputFileSystem
+								).readFile(targetPath, (err, existingContent) => {
+									if (
+										err ||
+										!content.equals(/** @type {Buffer} */ (existingContent))
+									) {
+										return doWrite(content);
 									}
-								);
+									return alreadyWritten();
+								});
 							}
 
 							return doWrite(content);
@@ -799,23 +935,28 @@ ${other}`);
 						// if the target file has already been written
 						if (targetFileGeneration !== undefined) {
 							// check if the Source has been written to this target file
-							const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
+							const writtenGeneration = /** @type {CacheEntry} */ (
+								cacheEntry
+							).writtenTo.get(targetPath);
 							if (writtenGeneration === targetFileGeneration) {
 								// if yes, we may skip writing the file
 								// if it's already there
 								// (we assume one doesn't modify files while the Compiler is running, other then removing them)
 
 								if (this._assetEmittingPreviousFiles.has(targetPath)) {
+									const sizeOnlySource = /** @type {SizeOnlySource} */ (
+										/** @type {CacheEntry} */ (cacheEntry).sizeOnlySource
+									);
+
 									// We assume that assets from the last compilation say intact on disk (they are not removed)
-									compilation.updateAsset(file, cacheEntry.sizeOnlySource, {
-										size: cacheEntry.sizeOnlySource.size()
+									compilation.updateAsset(file, sizeOnlySource, {
+										size: sizeOnlySource.size()
 									});
 
 									return callback();
-								} else {
-									// Settings immutable will make it accept file content without comparing when file exist
-									immutable = true;
 								}
+								// Settings immutable will make it accept file content without comparing when file exist
+								immutable = true;
 							} else if (!immutable) {
 								if (checkSimilarFile()) return;
 								// We wrote to this file before which has very likely a different content
@@ -827,11 +968,12 @@ ${other}`);
 
 						if (checkSimilarFile()) return;
 						if (this.options.output.compareBeforeEmit) {
-							this.outputFileSystem.stat(targetPath, (err, stats) => {
-								const exists = !err && stats.isFile();
+							/** @type {OutputFileSystem} */
+							(this.outputFileSystem).stat(targetPath, (err, stats) => {
+								const exists = !err && /** @type {IStats} */ (stats).isFile();
 
 								if (exists) {
-									processExistingFile(stats);
+									processExistingFile(/** @type {IStats} */ (stats));
 								} else {
 									processMissingFile();
 								}
@@ -841,8 +983,8 @@ ${other}`);
 						}
 					};
 
-					if (targetFile.match(/\/|\\/)) {
-						const fs = this.outputFileSystem;
+					if (/\/|\\/.test(targetFile)) {
+						const fs = /** @type {OutputFileSystem} */ (this.outputFileSystem);
 						const dir = dirname(fs, join(fs, outputPath, targetFile));
 						mkdirp(fs, dir, writeOut);
 					} else {
@@ -871,7 +1013,11 @@ ${other}`);
 		this.hooks.emit.callAsync(compilation, err => {
 			if (err) return callback(err);
 			outputPath = compilation.getPath(this.outputPath, {});
-			mkdirp(this.outputFileSystem, outputPath, emitFiles);
+			mkdirp(
+				/** @type {OutputFileSystem} */ (this.outputFileSystem),
+				outputPath,
+				emitFiles
+			);
 		});
 	}
 
@@ -880,11 +1026,34 @@ ${other}`);
 	 * @returns {void}
 	 */
 	emitRecords(callback) {
-		if (!this.recordsOutputPath) return callback();
+		if (this.hooks.emitRecords.isUsed()) {
+			if (this.recordsOutputPath) {
+				asyncLib.parallel(
+					[
+						cb => this.hooks.emitRecords.callAsync(cb),
+						this._emitRecords.bind(this)
+					],
+					err => callback(err)
+				);
+			} else {
+				this.hooks.emitRecords.callAsync(callback);
+			}
+		} else if (this.recordsOutputPath) {
+			this._emitRecords(callback);
+		} else {
+			callback();
+		}
+	}
 
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_emitRecords(callback) {
 		const writeFile = () => {
-			this.outputFileSystem.writeFile(
-				this.recordsOutputPath,
+			/** @type {OutputFileSystem} */
+			(this.outputFileSystem).writeFile(
+				/** @type {string} */ (this.recordsOutputPath),
 				JSON.stringify(
 					this.records,
 					(n, value) => {
@@ -907,16 +1076,20 @@ ${other}`);
 		};
 
 		const recordsOutputPathDirectory = dirname(
-			this.outputFileSystem,
-			this.recordsOutputPath
+			/** @type {OutputFileSystem} */ (this.outputFileSystem),
+			/** @type {string} */ (this.recordsOutputPath)
 		);
 		if (!recordsOutputPathDirectory) {
 			return writeFile();
 		}
-		mkdirp(this.outputFileSystem, recordsOutputPathDirectory, err => {
-			if (err) return callback(err);
-			writeFile();
-		});
+		mkdirp(
+			/** @type {OutputFileSystem} */ (this.outputFileSystem),
+			recordsOutputPathDirectory,
+			err => {
+				if (err) return callback(err);
+				writeFile();
+			}
+		);
 	}
 
 	/**
@@ -924,27 +1097,63 @@ ${other}`);
 	 * @returns {void}
 	 */
 	readRecords(callback) {
+		if (this.hooks.readRecords.isUsed()) {
+			if (this.recordsInputPath) {
+				asyncLib.parallel(
+					[
+						cb => this.hooks.readRecords.callAsync(cb),
+						this._readRecords.bind(this)
+					],
+					err => callback(err)
+				);
+			} else {
+				this.records = {};
+				this.hooks.readRecords.callAsync(callback);
+			}
+		} else if (this.recordsInputPath) {
+			this._readRecords(callback);
+		} else {
+			this.records = {};
+			callback();
+		}
+	}
+
+	/**
+	 * @param {Callback<void>} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_readRecords(callback) {
 		if (!this.recordsInputPath) {
 			this.records = {};
 			return callback();
 		}
-		this.inputFileSystem.stat(this.recordsInputPath, err => {
+		/** @type {InputFileSystem} */
+		(this.inputFileSystem).stat(this.recordsInputPath, err => {
 			// It doesn't exist
 			// We can ignore this.
 			if (err) return callback();
 
-			this.inputFileSystem.readFile(this.recordsInputPath, (err, content) => {
-				if (err) return callback(err);
+			/** @type {InputFileSystem} */
+			(this.inputFileSystem).readFile(
+				/** @type {string} */ (this.recordsInputPath),
+				(err, content) => {
+					if (err) return callback(err);
 
-				try {
-					this.records = parseJson(content.toString("utf-8"));
-				} catch (e) {
-					e.message = "Cannot parse records: " + e.message;
-					return callback(e);
-				}
+					try {
+						this.records = parseJson(
+							/** @type {Buffer} */ (content).toString("utf-8")
+						);
+					} catch (parseErr) {
+						return callback(
+							new Error(
+								`Cannot parse records: ${/** @type {Error} */ (parseErr).message}`
+							)
+						);
+					}
 
-				return callback();
-			});
+					return callback();
+				}
+			);
 		});
 	}
 
@@ -963,7 +1172,13 @@ ${other}`);
 		outputOptions,
 		plugins
 	) {
-		const childCompiler = new Compiler(this.context);
+		const childCompiler = new Compiler(this.context, {
+			...this.options,
+			output: {
+				...this.options.output,
+				...outputOptions
+			}
+		});
 		childCompiler.name = compilerName;
 		childCompiler.outputPath = this.outputPath;
 		childCompiler.inputFileSystem = this.inputFileSystem;
@@ -976,6 +1191,7 @@ ${other}`);
 		childCompiler.fsStartTime = this.fsStartTime;
 		childCompiler.cache = this.cache;
 		childCompiler.compilerPath = `${this.compilerPath}${compilerName}|${compilerIndex}|`;
+		childCompiler._backCompat = this._backCompat;
 
 		const relativeCompilerName = makePathsRelative(
 			this.context,
@@ -991,18 +1207,13 @@ ${other}`);
 			this.records[relativeCompilerName].push((childCompiler.records = {}));
 		}
 
-		childCompiler.options = {
-			...this.options,
-			output: {
-				...this.options.output,
-				...outputOptions
-			}
-		};
 		childCompiler.parentCompilation = compilation;
 		childCompiler.root = this.root;
 		if (Array.isArray(plugins)) {
 			for (const plugin of plugins) {
-				plugin.apply(childCompiler);
+				if (plugin) {
+					plugin.apply(childCompiler);
+				}
 			}
 		}
 		for (const name in this.hooks) {
@@ -1015,11 +1226,17 @@ ${other}`);
 					"invalid",
 					"done",
 					"thisCompilation"
-				].includes(name)
+				].includes(name) &&
+				childCompiler.hooks[/** @type {keyof Compiler["hooks"]} */ (name)]
 			) {
-				if (childCompiler.hooks[name]) {
-					childCompiler.hooks[name].taps = this.hooks[name].taps.slice();
-				}
+				childCompiler.hooks[
+					/** @type {keyof Compiler["hooks"]} */
+					(name)
+				].taps =
+					this.hooks[
+						/** @type {keyof Compiler["hooks"]} */
+						(name)
+					].taps.slice();
 			}
 		}
 
@@ -1033,9 +1250,13 @@ ${other}`);
 	}
 
 	isChild() {
-		return !!this.parentCompilation;
+		return Boolean(this.parentCompilation);
 	}
 
+	/**
+	 * @param {CompilationParams} params the compilation parameters
+	 * @returns {Compilation} compilation
+	 */
 	createCompilation(params) {
 		this._cleanupLastCompilation();
 		return (this._lastCompilation = new Compilation(this, params));
@@ -1058,7 +1279,7 @@ ${other}`);
 		this._cleanupLastNormalModuleFactory();
 		const normalModuleFactory = new NormalModuleFactory({
 			context: this.options.context,
-			fs: this.inputFileSystem,
+			fs: /** @type {InputFileSystem} */ (this.inputFileSystem),
 			resolverFactory: this.resolverFactory,
 			options: this.options.module,
 			associatedObjectForCache: this.root,
@@ -1084,7 +1305,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {Callback<Compilation>} callback signals when the compilation finishes
+	 * @param {RunCallback<Compilation>} callback signals when the compilation finishes
 	 * @returns {void}
 	 */
 	compile(callback) {
@@ -1135,7 +1356,7 @@ ${other}`);
 	}
 
 	/**
-	 * @param {Callback<void>} callback signals when the compiler closes
+	 * @param {RunCallback<void>} callback signals when the compiler closes
 	 * @returns {void}
 	 */
 	close(callback) {