webpack 5.59.0 → 5.76.0

package/lib/Compilation.js

@@ -43,6 +43,7 @@ const Module = require("./Module");
 const ModuleDependencyError = require("./ModuleDependencyError");
 const ModuleDependencyWarning = require("./ModuleDependencyWarning");
 const ModuleGraph = require("./ModuleGraph");
+const ModuleHashingError = require("./ModuleHashingError");
 const ModuleNotFoundError = require("./ModuleNotFoundError");
 const ModuleProfile = require("./ModuleProfile");
 const ModuleRestoreError = require("./ModuleRestoreError");
@@ -116,34 +117,34 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @callback Callback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @returns {void}
  */
 
 /**
  * @callback ModuleCallback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @param {Module=} result
  * @returns {void}
  */
 
 /**
  * @callback ModuleFactoryResultCallback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @param {ModuleFactoryResult=} result
  * @returns {void}
  */
 
 /**
  * @callback ModuleOrFactoryResultCallback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @param {Module | ModuleFactoryResult=} result
  * @returns {void}
  */
 
 /**
  * @callback ExecuteModuleCallback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @param {ExecuteModuleResult=} result
  * @returns {void}
  */
@@ -182,6 +183,7 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @typedef {Object} ChunkHashContext
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
  * @property {ModuleGraph} moduleGraph the module graph
  * @property {ChunkGraph} chunkGraph the chunk graph
@@ -429,6 +431,8 @@ class Compilation {
 	 * @param {CompilationParams} params the compilation parameters
 	 */
 	constructor(compiler, params) {
+		this._backCompat = compiler._backCompat;
+
 		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
 		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
 		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
@@ -559,6 +563,7 @@ class Compilation {
 		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
 		 */
 		const createProcessAssetsHook = (name, stage, getArgs, code) => {
+			if (!this._backCompat && code) return undefined;
 			const errorMessage =
 				reason => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
@@ -983,7 +988,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.asyncEntrypoints = [];
 		/** @type {Set<Chunk>} */
 		this.chunks = new Set();
-		arrayToSetDeprecation(this.chunks, "Compilation.chunks");
 		/** @type {ChunkGroup[]} */
 		this.chunkGroups = [];
 		/** @type {Map<string, ChunkGroup>} */
@@ -992,7 +996,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.namedChunks = new Map();
 		/** @type {Set<Module>} */
 		this.modules = new Set();
-		arrayToSetDeprecation(this.modules, "Compilation.modules");
+		if (this._backCompat) {
+			arrayToSetDeprecation(this.chunks, "Compilation.chunks");
+			arrayToSetDeprecation(this.modules, "Compilation.modules");
+		}
 		/** @private @type {Map<string, Module>} */
 		this._modules = new Map();
 		this.records = null;
@@ -1015,7 +1022,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {Map<DepConstructor, ModuleFactory>} */
 		this.dependencyFactories = new Map();
 		/** @type {DependencyTemplates} */
-		this.dependencyTemplates = new DependencyTemplates();
+		this.dependencyTemplates = new DependencyTemplates(
+			this.outputOptions.hashFunction
+		);
 		this.childrenCounters = {};
 		/** @type {Set<number|string>} */
 		this.usedChunkIds = null;
@@ -1286,7 +1295,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 			this._modules.set(identifier, module);
 			this.modules.add(module);
-			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+			if (this._backCompat)
+				ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 			if (currentProfile !== undefined) {
 				currentProfile.markIntegrationEnd();
 			}
@@ -1426,7 +1436,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
+		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], context: string|undefined, originModule: Module|null}>} */
 		const sortedDependencies = [];
 
 		/** @type {DependenciesBlock} */
@@ -1658,6 +1668,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					sortedDependencies.push({
 						factory: factoryCacheKey2,
 						dependencies: list,
+						context: dep.getContext(),
 						originModule: module
 					});
 				}
@@ -1701,7 +1712,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		this._modules.set(module.identifier(), module);
 		this.modules.add(module);
-		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 
 		this._handleModuleBuildAndDependencies(
 			originModule,
@@ -1926,7 +1938,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			// This avoids deadlocks for circular dependencies
 			if (this.processDependenciesQueue.isProcessing(module)) {
-				return callback();
+				return callback(null, module);
 			}
 
 			this.processModuleDependencies(module, err => {
@@ -2417,9 +2429,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statNew = 0;
 		/**
 		 * @param {Module} module module
-		 * @returns {{ modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
+		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
 		 */
 		const computeReferences = module => {
+			const id = chunkGraph.getModuleId(module);
 			/** @type {Map<Module, string | number | undefined>} */
 			let modules = undefined;
 			/** @type {(string | number)[] | undefined} */
@@ -2447,16 +2460,18 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					queue.push.apply(queue, block.blocks);
 				}
 			}
-			return { modules, blocks };
+			return { id, modules, blocks };
 		};
 		/**
 		 * @param {Module} module module
 		 * @param {Object} references references
+		 * @param {string | number} references.id id
 		 * @param {Map<Module, string | number>=} references.modules modules
 		 * @param {(string | number)[]=} references.blocks blocks
 		 * @returns {boolean} ok?
 		 */
-		const compareReferences = (module, { modules, blocks }) => {
+		const compareReferences = (module, { id, modules, blocks }) => {
+			if (id !== chunkGraph.getModuleId(module)) return false;
 			if (modules !== undefined) {
 				for (const [module, id] of modules) {
 					if (chunkGraph.getModuleId(module) !== id) return false;
@@ -2482,7 +2497,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
+			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
 			const cache = memCache.get(key);
 			if (cache === undefined) {
 				const memCache2 = new WeakTupleMap();
@@ -2777,8 +2792,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 		this.chunkGraph = chunkGraph;
 
-		for (const module of this.modules) {
-			ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+		if (this._backCompat) {
+			for (const module of this.modules) {
+				ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+			}
 		}
 
 		this.hooks.seal.call();
@@ -3045,14 +3062,16 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 									}
 									this.hooks.afterProcessAssets.call(this.assets);
 									this.logger.timeEnd("process assets");
-									this.assets = soonFrozenObjectDeprecation(
-										this.assets,
-										"Compilation.assets",
-										"DEP_WEBPACK_COMPILATION_ASSETS",
-										`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
+									this.assets = this._backCompat
+										? soonFrozenObjectDeprecation(
+												this.assets,
+												"Compilation.assets",
+												"DEP_WEBPACK_COMPILATION_ASSETS",
+												`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
 	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
 	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
-									);
+										  )
+										: Object.freeze(this.assets);
 
 									this.summarizeDependencies();
 									if (shouldRecord) {
@@ -3173,53 +3192,96 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	_runCodeGenerationJobs(jobs, callback) {
+		if (jobs.length === 0) {
+			return callback();
+		}
 		let statModulesFromCache = 0;
 		let statModulesGenerated = 0;
 		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
 			this;
 		const results = this.codeGenerationResults;
 		const errors = [];
-		asyncLib.eachLimit(
-			jobs,
-			this.options.parallelism,
-			({ module, hash, runtime, runtimes }, callback) => {
-				this._codeGenerationModule(
-					module,
-					runtime,
-					runtimes,
-					hash,
-					dependencyTemplates,
-					chunkGraph,
-					moduleGraph,
-					runtimeTemplate,
-					errors,
-					results,
-					(err, codeGenerated) => {
-						if (codeGenerated) statModulesGenerated++;
-						else statModulesFromCache++;
-						callback(err);
+		/** @type {Set<Module> | undefined} */
+		let notCodeGeneratedModules = undefined;
+		const runIteration = () => {
+			let delayedJobs = [];
+			let delayedModules = new Set();
+			asyncLib.eachLimit(
+				jobs,
+				this.options.parallelism,
+				(job, callback) => {
+					const { module } = job;
+					const { codeGenerationDependencies } = module;
+					if (codeGenerationDependencies !== undefined) {
+						if (
+							notCodeGeneratedModules === undefined ||
+							codeGenerationDependencies.some(dep => {
+								const referencedModule = moduleGraph.getModule(dep);
+								return notCodeGeneratedModules.has(referencedModule);
+							})
+						) {
+							delayedJobs.push(job);
+							delayedModules.add(module);
+							return callback();
+						}
 					}
-				);
-			},
-			err => {
-				if (err) return callback(err);
-				if (errors.length > 0) {
-					errors.sort(
-						compareSelect(err => err.module, compareModulesByIdentifier)
+					const { hash, runtime, runtimes } = job;
+					this._codeGenerationModule(
+						module,
+						runtime,
+						runtimes,
+						hash,
+						dependencyTemplates,
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						errors,
+						results,
+						(err, codeGenerated) => {
+							if (codeGenerated) statModulesGenerated++;
+							else statModulesFromCache++;
+							callback(err);
+						}
 					);
-					for (const error of errors) {
-						this.errors.push(error);
+				},
+				err => {
+					if (err) return callback(err);
+					if (delayedJobs.length > 0) {
+						if (delayedJobs.length === jobs.length) {
+							return callback(
+								new Error(
+									`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
+										delayedModules,
+										m => m.identifier()
+									).join(", ")}`
+								)
+							);
+						}
+						jobs = delayedJobs;
+						delayedJobs = [];
+						notCodeGeneratedModules = delayedModules;
+						delayedModules = new Set();
+						return runIteration();
+					}
+					if (errors.length > 0) {
+						errors.sort(
+							compareSelect(err => err.module, compareModulesByIdentifier)
+						);
+						for (const error of errors) {
+							this.errors.push(error);
+						}
 					}
+					this.logger.log(
+						`${Math.round(
+							(100 * statModulesGenerated) /
+								(statModulesGenerated + statModulesFromCache)
+						)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
+					);
+					callback();
 				}
-				this.logger.log(
-					`${Math.round(
-						(100 * statModulesGenerated) /
-							(statModulesGenerated + statModulesFromCache)
-					)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
-				);
-				callback();
-			}
-		);
+			);
+		};
+		runIteration();
 	}
 
 	/**
@@ -3269,7 +3331,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						moduleGraph,
 						dependencyTemplates,
 						runtimeTemplate,
-						runtime
+						runtime,
+						codeGenerationResults: results,
+						compilation: this
 					});
 				} catch (err) {
 					errors.push(new CodeGenerationError(module, err));
@@ -3453,7 +3517,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 */
 	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
 		// Deprecated ModuleGraph association
-		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 
 		// add it to the list
 		this.modules.add(module);
@@ -3497,10 +3562,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * If `module` is passed, `loc` and `request` must also be passed.
 	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
-	 * @param {Module} module the module the references the chunk group
-	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string} request the request from which the the chunk group is referenced
+	 * @param {Module=} module the module the references the chunk group
+	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
+	 * @param {string=} request the request from which the the chunk group is referenced
 	 * @returns {ChunkGroup} the new or existing chunk group
 	 */
 	addChunkInGroup(groupOptions, module, loc, request) {
@@ -3589,9 +3655,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				return chunk;
 			}
 		}
-		const chunk = new Chunk(name);
+		const chunk = new Chunk(name, this._backCompat);
 		this.chunks.add(chunk);
-		ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
+		if (this._backCompat)
+			ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
 		if (name) {
 			this.namedChunks.set(name, chunk);
 		}
@@ -3822,6 +3889,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		let statModulesFromCache = 0;
 		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
 		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
+		const errors = [];
 		for (const module of this.modules) {
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
@@ -3832,7 +3900,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 							module,
 							runtime,
 							digest,
-							digest.substr(0, hashDigestLength)
+							digest.slice(0, hashDigestLength)
 						);
 						statModulesFromCache++;
 						continue;
@@ -3846,13 +3914,20 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					hashFunction,
 					runtimeTemplate,
 					hashDigest,
-					hashDigestLength
+					hashDigestLength,
+					errors
 				);
 				if (memCache) {
 					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
 				}
 			}
 		}
+		if (errors.length > 0) {
+			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			for (const error of errors) {
+				this.errors.push(error);
+			}
+		}
 		this.logger.log(
 			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
 				Math.round(
@@ -3869,22 +3944,27 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		hashFunction,
 		runtimeTemplate,
 		hashDigest,
-		hashDigestLength
+		hashDigestLength,
+		errors
 	) {
-		const moduleHash = createHash(hashFunction);
-		module.updateHash(moduleHash, {
-			chunkGraph,
-			runtime,
-			runtimeTemplate
-		});
-		const moduleHashDigest = /** @type {string} */ (
-			moduleHash.digest(hashDigest)
-		);
+		let moduleHashDigest;
+		try {
+			const moduleHash = createHash(hashFunction);
+			module.updateHash(moduleHash, {
+				chunkGraph,
+				runtime,
+				runtimeTemplate
+			});
+			moduleHashDigest = /** @type {string} */ (moduleHash.digest(hashDigest));
+		} catch (err) {
+			errors.push(new ModuleHashingError(module, err));
+			moduleHashDigest = "XXXXXX";
+		}
 		chunkGraph.setModuleHashes(
 			module,
 			runtime,
 			moduleHashDigest,
-			moduleHashDigest.substr(0, hashDigestLength)
+			moduleHashDigest.slice(0, hashDigestLength)
 		);
 		return moduleHashDigest;
 	}
@@ -4030,6 +4110,7 @@ This prevents using hashes of each other and should be avoided.`);
 		const codeGenerationJobs = [];
 		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
 		const codeGenerationJobsMap = new Map();
+		const errors = [];
 
 		const processChunk = chunk => {
 			// Last minute module hash generation for modules that depend on chunk hashes
@@ -4044,7 +4125,8 @@ This prevents using hashes of each other and should be avoided.`);
 						hashFunction,
 						runtimeTemplate,
 						hashDigest,
-						hashDigestLength
+						hashDigestLength,
+						errors
 					);
 					let hashMap = codeGenerationJobsMap.get(hash);
 					if (hashMap) {
@@ -4068,15 +4150,16 @@ This prevents using hashes of each other and should be avoided.`);
 				}
 			}
 			this.logger.timeAggregate("hashing: hash runtime modules");
-			this.logger.time("hashing: hash chunks");
-			const chunkHash = createHash(hashFunction);
 			try {
+				this.logger.time("hashing: hash chunks");
+				const chunkHash = createHash(hashFunction);
 				if (outputOptions.hashSalt) {
 					chunkHash.update(outputOptions.hashSalt);
 				}
 				chunk.updateHash(chunkHash, chunkGraph);
 				this.hooks.chunkHash.call(chunk, chunkHash, {
 					chunkGraph,
+					codeGenerationResults: this.codeGenerationResults,
 					moduleGraph: this.moduleGraph,
 					runtimeTemplate: this.runtimeTemplate
 				});
@@ -4085,7 +4168,7 @@ This prevents using hashes of each other and should be avoided.`);
 				);
 				hash.update(chunkHashDigest);
 				chunk.hash = chunkHashDigest;
-				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+				chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 				const fullHashModules =
 					chunkGraph.getChunkFullHashModulesIterable(chunk);
 				if (fullHashModules) {
@@ -4100,13 +4183,19 @@ This prevents using hashes of each other and should be avoided.`);
 		};
 		otherChunks.forEach(processChunk);
 		for (const chunk of runtimeChunks) processChunk(chunk);
+		if (errors.length > 0) {
+			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			for (const error of errors) {
+				this.errors.push(error);
+			}
+		}
 
 		this.logger.timeAggregateEnd("hashing: hash runtime modules");
 		this.logger.timeAggregateEnd("hashing: hash chunks");
 		this.logger.time("hashing: hash digest");
 		this.hooks.fullHash.call(hash);
 		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
-		this.hash = this.fullHash.substr(0, hashDigestLength);
+		this.hash = this.fullHash.slice(0, hashDigestLength);
 		this.logger.timeEnd("hashing: hash digest");
 
 		this.logger.time("hashing: process full hash modules");
@@ -4126,7 +4215,7 @@ This prevents using hashes of each other and should be avoided.`);
 					module,
 					chunk.runtime,
 					moduleHashDigest,
-					moduleHashDigest.substr(0, hashDigestLength)
+					moduleHashDigest.slice(0, hashDigestLength)
 				);
 				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
 			}
@@ -4137,7 +4226,7 @@ This prevents using hashes of each other and should be avoided.`);
 				chunkHash.digest(hashDigest)
 			);
 			chunk.hash = chunkHashDigest;
-			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+			chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 			this.hooks.contentHash.call(chunk);
 		}
 		this.logger.timeEnd("hashing: process full hash modules");
@@ -4155,7 +4244,11 @@ This prevents using hashes of each other and should be avoided.`);
 			if (!isSourceEqual(this.assets[file], source)) {
 				this.errors.push(
 					new WebpackError(
-						`Conflict: Multiple assets emit different content to the same filename ${file}`
+						`Conflict: Multiple assets emit different content to the same filename ${file}${
+							assetInfo.sourceFilename
+								? `. Original source ${assetInfo.sourceFilename}`
+								: ""
+						}`
 					)
 				);
 				this.assets[file] = source;
@@ -4715,7 +4808,7 @@ This prevents using hashes of each other and should be avoided.`);
 					this.outputOptions;
 				const runtimeTemplate = this.runtimeTemplate;
 
-				const chunk = new Chunk("build time chunk");
+				const chunk = new Chunk("build time chunk", this._backCompat);
 				chunk.id = chunk.name;
 				chunk.ids = [chunk.id];
 				chunk.runtime = runtime;
@@ -4739,6 +4832,9 @@ This prevents using hashes of each other and should be avoided.`);
 					chunkGraph.connectChunkAndModule(chunk, module);
 				}
 
+				/** @type {WebpackError[]} */
+				const errors = [];
+
 				// Hash modules
 				for (const module of modules) {
 					this._createModuleHash(
@@ -4748,15 +4844,14 @@ This prevents using hashes of each other and should be avoided.`);
 						hashFunction,
 						runtimeTemplate,
 						hashDigest,
-						hashDigestLength
+						hashDigestLength,
+						errors
 					);
 				}
 
 				const codeGenerationResults = new CodeGenerationResults(
 					this.outputOptions.hashFunction
 				);
-				/** @type {WebpackError[]} */
-				const errors = [];
 				/**
 				 * @param {Module} module the module
 				 * @param {Callback} callback callback