webpack 5.90.3 → 5.91.0

package/lib/Compilation.js

@@ -88,6 +88,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
@@ -101,8 +102,11 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./RequestShortener")} RequestShortener */
@@ -113,9 +117,13 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
 /** @typedef {import("./util/Hash")} Hash */
-/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T> */
+/**
+ * @template T
+ * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
+ */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-
+/** @typedef {WeakMap<Dependency, Module>} References */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /**
  * @callback Callback
  * @param {(WebpackError | null)=} err
@@ -344,12 +352,23 @@ const { isSourceEqual } = require("./util/source");
 
 /** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
 
+/** @typedef {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} CodeGenerationJobs */
+
+/** @typedef {{javascript: ModuleTemplate}} ModuleTemplates */
+
+/** @typedef {Set<Module>} NotCodeGeneratedModules */
+
 /** @type {AssetInfo} */
 const EMPTY_ASSET_INFO = Object.freeze({});
 
 const esmDependencyCategory = "esm";
+
 // TODO webpack 6: remove
 const deprecatedNormalModuleLoaderHook = util.deprecate(
+	/**
+	 * @param {Compilation} compilation compilation
+	 * @returns {NormalModuleCompilationHooks["loader"]} hooks
+	 */
 	compilation => {
 		return require("./NormalModule").getCompilationHooks(compilation).loader;
 	},
@@ -358,6 +377,9 @@ const deprecatedNormalModuleLoaderHook = util.deprecate(
 );
 
 // TODO webpack 6: remove
+/**
+ * @param {ModuleTemplates | undefined} moduleTemplates module templates
+ */
 const defineRemovedModuleTemplates = moduleTemplates => {
 	Object.defineProperties(moduleTemplates, {
 		asset: {
@@ -382,30 +404,11 @@ const defineRemovedModuleTemplates = moduleTemplates => {
 	moduleTemplates = undefined;
 };
 
-const byId = compareSelect(
-	/**
-	 * @param {Chunk} c chunk
-	 * @returns {number | string} id
-	 */ c => c.id,
-	compareIds
-);
+const byId = compareSelect(c => c.id, compareIds);
 
 const byNameOrHash = concatComparators(
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} name
-		 */
-		c => c.name,
-		compareIds
-	),
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} hash
-		 */ c => c.fullHash,
-		compareIds
-	)
+	compareSelect(c => c.name, compareIds),
+	compareSelect(c => c.fullHash, compareIds)
 );
 
 const byMessage = compareSelect(err => `${err.message}`, compareStringsNumeric);
@@ -440,6 +443,10 @@ class Compilation {
 		const processAssetsHook = new AsyncSeriesHook(["assets"]);
 
 		let savedAssets = new Set();
+		/**
+		 * @param {CompilationAssets} assets assets
+		 * @returns {CompilationAssets} new assets
+		 */
 		const popNewAssets = assets => {
 			let newAssets = undefined;
 			for (const file of Object.keys(assets)) {
@@ -667,7 +674,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[Iterable<Module>]>} */
 			afterOptimizeModules: new SyncHook(["modules"]),
 
-			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]]>} */
+			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]], boolean | void>} */
 			optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),
 			/** @type {SyncHook<[Iterable<Chunk>, ChunkGroup[]]>} */
 			afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),
@@ -677,7 +684,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
 			afterOptimizeTree: new SyncHook(["chunks", "modules"]),
 
-			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>], void>} */
 			optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
 			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
 			afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
@@ -690,7 +697,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInChunk: new HookMap(
 				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
@@ -824,7 +831,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
 			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
-			/** @type {SyncBailHook<[], boolean>} */
+			/** @type {SyncBailHook<[], boolean | undefined>} */
 			needAdditionalSeal: new SyncBailHook([]),
 			/** @type {AsyncSeriesHook<[]>} */
 			afterSeal: new AsyncSeriesHook([]),
@@ -878,12 +885,17 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 		/** @type {string=} */
 		this.name = undefined;
+		/** @type {number | undefined} */
 		this.startTime = undefined;
+		/** @type {number | undefined} */
 		this.endTime = undefined;
 		/** @type {Compiler} */
 		this.compiler = compiler;
 		this.resolverFactory = compiler.resolverFactory;
-		this.inputFileSystem = compiler.inputFileSystem;
+		/** @type {InputFileSystem} */
+		this.inputFileSystem =
+			/** @type {InputFileSystem} */
+			(compiler.inputFileSystem);
 		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
 			unmanagedPaths: compiler.unmanagedPaths,
 			managedPaths: compiler.managedPaths,
@@ -907,7 +919,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		this.logger = this.getLogger("webpack.Compilation");
 
-		const options = compiler.options;
+		const options = /** @type {WebpackOptions} */ (compiler.options);
 		this.options = options;
 		this.outputOptions = options && options.output;
 		/** @type {boolean} */
@@ -923,7 +935,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.outputOptions,
 			this.requestShortener
 		);
-		/** @type {{javascript: ModuleTemplate}} */
+		/** @type {ModuleTemplates} */
 		this.moduleTemplates = {
 			javascript: new ModuleTemplate(this.runtimeTemplate, this)
 		};
@@ -1066,6 +1078,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		// TODO webpack 6 remove
 		this.compilationDependencies = {
 			add: util.deprecate(
+				/**
+				 * @param {string} item item
+				 * @returns {LazySet<string>} file dependencies
+				 */
 				item => this.fileDependencies.add(item),
 				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
 				"DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
@@ -1119,12 +1135,20 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		}
 	}
 
+	/**
+	 * @param {NormalizedStatsOptions} options options
+	 * @returns {StatsFactory} the stats factory
+	 */
 	createStatsFactory(options) {
 		const statsFactory = new StatsFactory();
 		this.hooks.statsFactory.call(statsFactory, options);
 		return statsFactory;
 	}
 
+	/**
+	 * @param {NormalizedStatsOptions} options options
+	 * @returns {StatsPrinter} the stats printer
+	 */
 	createStatsPrinter(options) {
 		const statsPrinter = new StatsPrinter();
 		this.hooks.statsPrinter.call(statsPrinter, options);
@@ -1164,7 +1188,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					case LogType.warn:
 					case LogType.error:
 					case LogType.trace:
-						trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
+						trace = ErrorHelpers.cutOffLoaderExecution(
+							/** @type {string} */ (new Error("Trace").stack)
+						)
 							.split("\n")
 							.slice(3);
 						break;
@@ -1314,7 +1340,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 */
 	getModule(module) {
 		const identifier = module.identifier();
-		return this._modules.get(identifier);
+		return /** @type {Module} */ (this._modules.get(identifier));
 	}
 
 	/**
@@ -1375,7 +1401,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.options,
 					this,
 					this.resolverFactory.get("normal", module.resolveOptions),
-					this.inputFileSystem,
+					/** @type {InputFileSystem} */ (this.inputFileSystem),
 					err => {
 						if (currentProfile !== undefined) {
 							currentProfile.markBuildingEnd();
@@ -1392,7 +1418,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								currentProfile.markStoringEnd();
 							}
 							if (err) {
-								this.hooks.failedModule.call(module, err);
+								this.hooks.failedModule.call(
+									module,
+									/** @type {WebpackError} */ (err)
+								);
 								return callback(new ModuleStoreError(module, err));
 							}
 							this.hooks.succeedModule.call(module);
@@ -1418,6 +1447,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	processModuleDependenciesNonRecursive(module) {
+		/**
+		 * @param {DependenciesBlock} block block
+		 */
 		const processDependenciesBlock = block => {
 			if (block.dependencies) {
 				let i = 0;
@@ -1463,6 +1495,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let inProgressSorting = 1;
 		let inProgressTransitive = 1;
 
+		/**
+		 * @param {WebpackError=} err error
+		 * @returns {void}
+		 */
 		const onDependenciesSorted = err => {
 			if (err) return callback(err);
 
@@ -1494,6 +1530,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
 		};
 
+		/**
+		 * @param {WebpackError=} err error
+		 * @returns {void}
+		 */
 		const onTransitiveTasksFinished = err => {
 			if (err) return callback(err);
 			this.processDependenciesQueue.decreaseParallelism();
@@ -1541,7 +1581,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							if (err) {
 								if (inProgressSorting <= 0) return;
 								inProgressSorting = -1;
-								onDependenciesSorted(err);
+								onDependenciesSorted(/** @type {WebpackError} */ (err));
 								return;
 							}
 							try {
@@ -1596,7 +1636,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							} catch (err) {
 								if (inProgressSorting <= 0) return;
 								inProgressSorting = -1;
-								onDependenciesSorted(err);
+								onDependenciesSorted(/** @type {WebpackError} */ (err));
 								return;
 							}
 							if (--inProgressSorting === 0) onDependenciesSorted();
@@ -1686,7 +1726,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {DependenciesBlock[]} */
 			const queue = [module];
 			do {
-				const block = queue.pop();
+				const block = /** @type {DependenciesBlock} */ (queue.pop());
 				if (block.dependencies) {
 					currentBlock = block;
 					let i = 0;
@@ -1703,6 +1743,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		if (--inProgressSorting === 0) onDependenciesSorted();
 	}
 
+	/**
+	 * @private
+	 * @param {Module} originModule original module
+	 * @param {Dependency} dependency dependency
+	 * @param {Module} module cached module
+	 * @param {Callback} callback callback
+	 */
 	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
 		const moduleGraph = this.moduleGraph;
 
@@ -1727,6 +1774,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
+	/**
+	 * @private
+	 * @param {Module} originModule original modules
+	 * @param {Dependency} dependency dependency
+	 * @param {Module} module cached module
+	 */
 	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
 		const moduleGraph = this.moduleGraph;
 
@@ -1813,27 +1866,30 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					moduleGraph.setProfile(newModule, currentProfile);
 				}
 
-				this.addModule(newModule, (err, module) => {
+				this.addModule(newModule, (err, _module) => {
 					if (err) {
 						applyFactoryResultDependencies();
 						if (!err.module) {
-							err.module = module;
+							err.module = _module;
 						}
 						this.errors.push(err);
 
 						return callback(err);
 					}
 
+					const module =
+						/** @type {Module & { restoreFromUnsafeCache?: Function }} */
+						(_module);
+
 					if (
 						this._unsafeCache &&
 						factoryResult.cacheable !== false &&
-						/** @type {any} */ (module).restoreFromUnsafeCache &&
+						module.restoreFromUnsafeCache &&
 						this._unsafeCachePredicate(module)
 					) {
 						const unsafeCacheableModule =
-							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
-								module
-							);
+							/** @type {Module & { restoreFromUnsafeCache: Function }} */
+							(module);
 						for (let i = 0; i < dependencies.length; i++) {
 							const dependency = dependencies[i];
 							moduleGraph.setResolvedModule(
@@ -1888,6 +1944,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
+	/**
+	 * @private
+	 * @param {Module} originModule original module
+	 * @param {Module} module module
+	 * @param {boolean} recursive true if make it recursive, otherwise false
+	 * @param {boolean} checkCycle true if need to check cycle, otherwise false
+	 * @param {ModuleCallback} callback callback
+	 * @returns {void}
+	 */
 	_handleModuleBuildAndDependencies(
 		originModule,
 		module,
@@ -2164,7 +2229,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 			};
 			entryData[target].push(entry);
-			this.entries.set(name, entryData);
+			this.entries.set(
+				/** @type {NonNullable<EntryOptions["name"]>} */ (name),
+				entryData
+			);
 		} else {
 			entryData[target].push(entry);
 			for (const key of Object.keys(options)) {
@@ -2204,7 +2272,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.hooks.failedEntry.call(entry, options, err);
 					return callback(err);
 				}
-				this.hooks.succeedEntry.call(entry, options, module);
+				this.hooks.succeedEntry.call(
+					entry,
+					options,
+					/** @type {Module} */ (module)
+				);
 				return callback(null, module);
 			}
 		);
@@ -2264,6 +2336,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 	}
 
+	/**
+	 * @private
+	 * @param {Set<Module>} modules modules
+	 */
 	_computeAffectedModules(modules) {
 		const moduleMemCacheCache = this.compiler.moduleMemCaches;
 		if (!moduleMemCacheCache) return;
@@ -2280,8 +2356,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statReferencesChanged = 0;
 		let statWithoutBuild = 0;
 
+		/**
+		 * @param {Module} module module
+		 * @returns {References | undefined} references
+		 */
 		const computeReferences = module => {
-			/** @type {WeakMap<Dependency, Module>} */
+			/** @type {References | undefined} */
 			let references = undefined;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
@@ -2295,7 +2375,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module the module
-		 * @param {WeakMap<Dependency, Module>} references references
+		 * @param {References | undefined} references references
 		 * @returns {boolean} true, when the references differ
 		 */
 		const compareReferences = (module, references) => {
@@ -2367,6 +2447,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 		}
 
+		/**
+		 * @param {readonly ModuleGraphConnection[]} connections connections
+		 * @returns {symbol|boolean} result
+		 */
 		const reduceAffectType = connections => {
 			let affected = false;
 			for (const { dependency } of connections) {
@@ -2442,13 +2526,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statNew = 0;
 		/**
 		 * @param {Module} module module
-		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
+		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} references
 		 */
 		const computeReferences = module => {
 			const id = chunkGraph.getModuleId(module);
-			/** @type {Map<Module, string | number | undefined>} */
+			/** @type {Map<Module, string | number | undefined> | undefined} */
 			let modules = undefined;
-			/** @type {(string | number)[] | undefined} */
+			/** @type {(string | number | null)[] | undefined} */
 			let blocks = undefined;
 			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
 			if (outgoing !== undefined) {
@@ -2479,8 +2563,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @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
+		 * @param {Map<Module, string | number | undefined>=} references.modules modules
+		 * @param {(string | number | null)[]=} references.blocks blocks
 		 * @returns {boolean} ok?
 		 */
 		const compareReferences = (module, { id, modules, blocks }) => {
@@ -2510,7 +2594,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { id: string | number, 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 | null)[]}, memCache: WeakTupleMap<any[], any> }} */
 			const cache = memCache.get(key);
 			if (cache === undefined) {
 				const memCache2 = new WeakTupleMap();
@@ -2539,6 +2623,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
+	/**
+	 * @param {Callback} callback callback
+	 */
 	finish(callback) {
 		this.factorizeQueue.clear();
 		if (this.profile) {
@@ -2546,6 +2633,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			const ParallelismFactorCalculator = require("./util/ParallelismFactorCalculator");
 			const p = new ParallelismFactorCalculator();
 			const moduleGraph = this.moduleGraph;
+			/** @type {Map<Module, ModuleProfile>} */
 			const modulesWithProfiles = new Map();
 			for (const module of this.modules) {
 				const profile = moduleGraph.getProfile(module);
@@ -2606,6 +2694,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					logger.debug(msg);
 				}
 			};
+			/**
+			 * @param {string} category a category
+			 * @param {(profile: ModuleProfile) => number} getDuration get duration callback
+			 * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback
+			 */
 			const logNormalSummary = (category, getDuration, getParallelism) => {
 				let sum = 0;
 				let max = 0;
@@ -2630,6 +2723,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					`${Math.round(sum)} ms ${category}`
 				);
 			};
+			/**
+			 * @param {string} category a category
+			 * @param {(profile: ModuleProfile) => number} getDuration get duration callback
+			 * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback
+			 */
 			const logByLoadersSummary = (category, getDuration, getParallelism) => {
 				const map = new Map();
 				for (const [module, profile] of modulesWithProfiles) {
@@ -2728,7 +2826,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		const { modules, moduleMemCaches } = this;
 		this.hooks.finishModules.callAsync(modules, err => {
 			this.logger.timeEnd("finish modules");
-			if (err) return callback(err);
+			if (err) return callback(/** @type {WebpackError} */ (err));
 
 			// extract warnings and errors from modules
 			this.moduleGraph.freeze("dependency errors");
@@ -2894,12 +2992,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 Entrypoints that depend on other entrypoints do not have their own runtime.
 They will use the runtime(s) from referenced entrypoints instead.
 Remove the 'runtime' option from the entrypoint.`);
-				const entry = this.entrypoints.get(name);
+				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
 				err.chunk = entry.getEntrypointChunk();
 				this.errors.push(err);
 			}
 			if (dependOn) {
-				const entry = this.entrypoints.get(name);
+				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
 				const referencedChunks = entry
 					.getEntrypointChunk()
 					.getAllReferencedChunks();
@@ -2927,7 +3025,7 @@ Remove the 'runtime' option from the entrypoint.`);
 					connectChunkGroupParentAndChild(dependency, entry);
 				}
 			} else if (runtime) {
-				const entry = this.entrypoints.get(name);
+				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
 				let chunk = this.namedChunks.get(runtime);
 				if (chunk) {
 					if (!runtimeChunks.has(chunk)) {
@@ -2938,7 +3036,9 @@ Did you mean to use 'dependOn: ${JSON.stringify(
 								runtime
 							)}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used.
 Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`);
-						const entryChunk = entry.getEntrypointChunk();
+						const entryChunk =
+							/** @type {Chunk} */
+							(entry.getEntrypointChunk());
 						err.chunk = entryChunk;
 						this.errors.push(err);
 						entry.setRuntimeChunk(entryChunk);
@@ -3077,16 +3177,18 @@ 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 = 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.
+									this.assets = /** @type {CompilationAssets} */ (
+										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);
+												)
+											: Object.freeze(this.assets)
+									);
 
 									this.summarizeDependencies();
 									if (shouldRecord) {
@@ -3172,12 +3274,15 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		return hasProblems;
 	}
 
+	/**
+	 * @param {Callback} callback callback
+	 */
 	codeGeneration(callback) {
 		const { chunkGraph } = this;
 		this.codeGenerationResults = new CodeGenerationResults(
 			this.outputOptions.hashFunction
 		);
-		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		/** @type {CodeGenerationJobs} */
 		const jobs = [];
 		for (const module of this.modules) {
 			const runtimes = chunkGraph.getModuleRuntimes(module);
@@ -3206,6 +3311,12 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		this._runCodeGenerationJobs(jobs, callback);
 	}
 
+	/**
+	 * @private
+	 * @param {CodeGenerationJobs} jobs code generation jobs
+	 * @param {Callback} callback callback
+	 * @returns {void}
+	 */
 	_runCodeGenerationJobs(jobs, callback) {
 		if (jobs.length === 0) {
 			return callback();
@@ -3217,9 +3328,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const results = this.codeGenerationResults;
 		/** @type {WebpackError[]} */
 		const errors = [];
-		/** @type {Set<Module> | undefined} */
+		/** @type {NotCodeGeneratedModules | undefined} */
 		let notCodeGeneratedModules = undefined;
 		const runIteration = () => {
+			/** @type {CodeGenerationJobs} */
 			let delayedJobs = [];
 			let delayedModules = new Set();
 			asyncLib.eachLimit(
@@ -3232,8 +3344,12 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						if (
 							notCodeGeneratedModules === undefined ||
 							codeGenerationDependencies.some(dep => {
-								const referencedModule = moduleGraph.getModule(dep);
-								return notCodeGeneratedModules.has(referencedModule);
+								const referencedModule = /** @type {Module} */ (
+									moduleGraph.getModule(dep)
+								);
+								return /** @type {NotCodeGeneratedModules} */ (
+									notCodeGeneratedModules
+								).has(referencedModule);
 							})
 						) {
 							delayedJobs.push(job);
@@ -3265,11 +3381,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					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(", ")}`
+								/** @type {WebpackError} */ (
+									new Error(
+										`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
+											delayedModules,
+											m => m.identifier()
+										).join(", ")}`
+									)
 								)
 							);
 						}
@@ -3336,7 +3454,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			)
 		);
 		cache.get((err, cachedResult) => {
-			if (err) return callback(err);
+			if (err) return callback(/** @type {WebpackError} */ (err));
 			let result;
 			if (!cachedResult) {
 				try {
@@ -3353,7 +3471,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						compilation: this
 					});
 				} catch (err) {
-					errors.push(new CodeGenerationError(module, err));
+					errors.push(
+						new CodeGenerationError(module, /** @type {Error} */ (err))
+					);
 					result = cachedResult = {
 						sources: new Map(),
 						runtimeRequirements: null
@@ -3366,7 +3486,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				results.add(module, runtime, result);
 			}
 			if (!cachedResult) {
-				cache.store(result, err => callback(err, codeGenerated));
+				cache.store(result, err =>
+					callback(/** @type {WebpackError} */ (err), codeGenerated)
+				);
 			} else {
 				callback(null, codeGenerated);
 			}
@@ -3835,7 +3957,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const blocks = block.blocks;
 		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
 			const asyncBlock = blocks[indexBlock];
-			const chunkGroup = this.chunkGraph.getBlockChunkGroup(asyncBlock);
+			const chunkGroup =
+				/** @type {ChunkGroup} */
+				(this.chunkGraph.getBlockChunkGroup(asyncBlock));
 			// Grab all chunks from the first Block's AsyncDepBlock
 			const chunks = chunkGroup.chunks;
 			// For each chunk in chunkGroup
@@ -3906,6 +4030,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;
+		/** @type {WebpackError[]} */
 		const errors = [];
 		for (const module of this.modules) {
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
@@ -3954,6 +4079,18 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		);
 	}
 
+	/**
+	 * @private
+	 * @param {Module} module module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {RuntimeSpec} runtime runtime
+	 * @param {OutputOptions["hashFunction"]} hashFunction hash function
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @param {OutputOptions["hashDigest"]} hashDigest hash digest
+	 * @param {OutputOptions["hashDigestLength"]} hashDigestLength hash digest length
+	 * @param {WebpackError[]} errors errors
+	 * @returns {string} module hash digest
+	 */
 	_createModuleHash(
 		module,
 		chunkGraph,
@@ -3974,7 +4111,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			});
 			moduleHashDigest = /** @type {string} */ (moduleHash.digest(hashDigest));
 		} catch (err) {
-			errors.push(new ModuleHashingError(module, err));
+			errors.push(new ModuleHashingError(module, /** @type {Error} */ (err)));
 			moduleHashDigest = "XXXXXX";
 		}
 		chunkGraph.setModuleHashes(
@@ -3988,7 +4125,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	createHash() {
 		this.logger.time("hashing: initialize hash");
-		const chunkGraph = this.chunkGraph;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const runtimeTemplate = this.runtimeTemplate;
 		const outputOptions = this.outputOptions;
 		const hashFunction = outputOptions.hashFunction;
@@ -4083,7 +4220,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			for (const chunk of runtimeChunks) {
 				const hasFullHashModules =
 					chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
-				const info = runtimeChunksMap.get(chunk);
+				const info =
+					/** @type {RuntimeChunkInfo} */
+					(runtimeChunksMap.get(chunk));
 				for (const otherInfo of info.referencedBy) {
 					if (hasFullHashModules) {
 						chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
@@ -4127,8 +4266,12 @@ 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();
+		/** @type {WebpackError[]} */
 		const errors = [];
 
+		/**
+		 * @param {Chunk} chunk chunk
+		 */
 		const processChunk = chunk => {
 			// Last minute module hash generation for modules that depend on chunk hashes
 			this.logger.time("hashing: hash runtime modules");
@@ -4217,7 +4360,9 @@ This prevents using hashes of each other and should be avoided.`);
 
 		this.logger.time("hashing: process full hash modules");
 		for (const chunk of fullHashChunks) {
-			for (const module of chunkGraph.getChunkFullHashModulesIterable(chunk)) {
+			for (const module of /** @type {Iterable<RuntimeModule>} */ (
+				chunkGraph.getChunkFullHashModulesIterable(chunk)
+			)) {
 				const moduleHash = createHash(hashFunction);
 				module.updateHash(moduleHash, {
 					chunkGraph,
@@ -4291,6 +4436,9 @@ This prevents using hashes of each other and should be avoided.`);
 		const newRelated = newInfo && newInfo.related;
 		if (oldRelated) {
 			for (const key of Object.keys(oldRelated)) {
+				/**
+				 * @param {string} name name
+				 */
 				const remove = name => {
 					const relatedIn = this._assetsRelatedIn.get(name);
 					if (relatedIn === undefined) return;
@@ -4311,6 +4459,9 @@ This prevents using hashes of each other and should be avoided.`);
 		}
 		if (newRelated) {
 			for (const key of Object.keys(newRelated)) {
+				/**
+				 * @param {string} name name
+				 */
 				const add = name => {
 					let relatedIn = this._assetsRelatedIn.get(name);
 					if (relatedIn === undefined) {
@@ -4335,7 +4486,7 @@ This prevents using hashes of each other and should be avoided.`);
 	/**
 	 * @param {string} file file name
 	 * @param {Source | function(Source): Source} newSourceOrFunction new asset source or function converting old to new
-	 * @param {AssetInfo | function(AssetInfo | undefined): AssetInfo} assetInfoUpdateOrFunction new asset info or function converting old to new
+	 * @param {(AssetInfo | function(AssetInfo | undefined): AssetInfo) | undefined} assetInfoUpdateOrFunction new asset info or function converting old to new
 	 */
 	updateAsset(
 		file,
@@ -4366,6 +4517,10 @@ This prevents using hashes of each other and should be avoided.`);
 		}
 	}
 
+	/**
+	 * @param {string} file file name
+	 * @param {string} newFile the new name of file
+	 */
 	renameAsset(file, newFile) {
 		const source = this.assets[file];
 		if (!source) {
@@ -4504,9 +4659,10 @@ This prevents using hashes of each other and should be avoided.`);
 	createModuleAssets() {
 		const { chunkGraph } = this;
 		for (const module of this.modules) {
-			if (module.buildInfo.assets) {
-				const assetsInfo = module.buildInfo.assetsInfo;
-				for (const assetName of Object.keys(module.buildInfo.assets)) {
+			const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+			if (buildInfo.assets) {
+				const assetsInfo = buildInfo.assetsInfo;
+				for (const assetName of Object.keys(buildInfo.assets)) {
 					const fileName = this.getPath(assetName, {
 						chunkGraph: this.chunkGraph,
 						module
@@ -4516,7 +4672,7 @@ This prevents using hashes of each other and should be avoided.`);
 					}
 					this.emitAsset(
 						fileName,
-						module.buildInfo.assets[assetName],
+						buildInfo.assets[assetName],
 						assetsInfo ? assetsInfo.get(assetName) : undefined
 					);
 					this.hooks.moduleAsset.call(module, fileName);
@@ -4563,7 +4719,9 @@ This prevents using hashes of each other and should be avoided.`);
 						runtimeTemplate: this.runtimeTemplate
 					});
 				} catch (err) {
-					this.errors.push(new ChunkRenderError(chunk, "", err));
+					this.errors.push(
+						new ChunkRenderError(chunk, "", /** @type {Error} */ (err))
+					);
 					return callback();
 				}
 				asyncLib.forEach(
@@ -4586,6 +4744,10 @@ This prevents using hashes of each other and should be avoided.`);
 							let assetInfo;
 
 							let inTry = true;
+							/**
+							 * @param {Error} err error
+							 * @returns {void}
+							 */
 							const errorAndCallback = err => {
 								const filename =
 									file ||
@@ -4813,7 +4975,7 @@ This prevents using hashes of each other and should be avoided.`);
 				});
 			},
 			err => {
-				if (err) return callback(err);
+				if (err) return callback(/** @type {WebpackError} */ (err));
 
 				// Create new chunk graph, chunk and entrypoint for the build time execution
 				const chunkGraph = new ChunkGraph(
@@ -4996,7 +5158,10 @@ This prevents using hashes of each other and should be avoided.`);
 									missingDependencies,
 									buildDependencies
 								);
-								if (module.buildInfo.cacheable === false) {
+								if (
+									/** @type {BuildInfo} */ (module.buildInfo).cacheable ===
+									false
+								) {
 									cacheable = false;
 								}
 								if (module.buildInfo && module.buildInfo.assets) {
@@ -5098,7 +5263,8 @@ This prevents using hashes of each other and should be avoided.`);
 										chunk
 									)) {
 										__webpack_require_module__(
-											moduleArgumentsMap.get(runtimeModule)
+											/** @type {ExecuteModuleArgument} */
+											(moduleArgumentsMap.get(runtimeModule))
 										);
 									}
 									exports = __webpack_require__(module.identifier());
@@ -5229,6 +5395,9 @@ Object.defineProperty(compilationPrototype, "cache", {
 		"DEP_WEBPACK_COMPILATION_CACHE"
 	),
 	set: util.deprecate(
+		/**
+		 * @param {any} v value
+		 */
 		v => {},
 		"Compilation.cache was removed in favor of Compilation.getCache()",
 		"DEP_WEBPACK_COMPILATION_CACHE"