webpack 5.90.2 → 5.90.3

package/lib/NormalModule.js

@@ -49,7 +49,6 @@ const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext} NormalModuleLoaderContext */
 /** @typedef {import("../declarations/WebpackOptions").Mode} Mode */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
@@ -58,17 +57,23 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("./Generator")} Generator */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./Module").BuildMeta} BuildMeta */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
+/** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
+/** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./ModuleTypeConstants").JavaScriptModuleTypes} JavaScriptModuleTypes */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./RequestShortener")} RequestShortener */
+/** @typedef {import("./ResolverFactory").ResolveContext} ResolveContext */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./logging/Logger").Logger} WebpackLogger */
@@ -78,6 +83,11 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {{[k: string]: any}} ParserOptions */
+/** @typedef {{[k: string]: any}} GeneratorOptions */
+
+/** @typedef {UnsafeCacheData & { parser: undefined | Parser, parserOptions: undefined | ParserOptions, generator: undefined | Generator, generatorOptions: undefined | GeneratorOptions }} NormalModuleUnsafeCacheData */
+
 /**
  * @typedef {Object} SourceMap
  * @property {number} version
@@ -212,9 +222,9 @@ makeSerializable(
  * @property {string} context context directory for resolving
  * @property {string=} matchResource path + query of the matched resource (virtual)
  * @property {Parser} parser the parser used
- * @property {Record<string, any>=} parserOptions the options of the parser used
+ * @property {ParserOptions=} parserOptions the options of the parser used
  * @property {Generator} generator the generator used
- * @property {Record<string, any>=} generatorOptions the options of the generator used
+ * @property {GeneratorOptions=} generatorOptions the options of the generator used
  * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
  */
 
@@ -264,9 +274,12 @@ class NormalModule extends Module {
 				),
 				needBuild: new AsyncSeriesBailHook(["module", "context"])
 			};
-			compilationHooksMap.set(compilation, hooks);
+			compilationHooksMap.set(
+				compilation,
+				/** @type {NormalModuleCompilationHooks} */ (hooks)
+			);
 		}
-		return hooks;
+		return /** @type {NormalModuleCompilationHooks} */ (hooks);
 	}
 
 	/**
@@ -300,11 +313,13 @@ class NormalModule extends Module {
 		this.rawRequest = rawRequest;
 		/** @type {boolean} */
 		this.binary = /^(asset|webassembly)\b/.test(type);
-		/** @type {Parser} */
+		/** @type {undefined | Parser} */
 		this.parser = parser;
+		/** @type {undefined | ParserOptions} */
 		this.parserOptions = parserOptions;
-		/** @type {Generator} */
+		/** @type {undefined | Generator} */
 		this.generator = generator;
+		/** @type {undefined | GeneratorOptions} */
 		this.generatorOptions = generatorOptions;
 		/** @type {string} */
 		this.resource = resource;
@@ -319,13 +334,22 @@ class NormalModule extends Module {
 		}
 
 		// Info from Build
-		/** @type {(WebpackError | null)=} */
+		/** @type {WebpackError | null} */
 		this.error = null;
-		/** @private @type {Source=} */
+		/**
+		 * @private
+		 * @type {Source | null}
+		 */
 		this._source = null;
-		/** @private @type {Map<string, number> | undefined} **/
+		/**
+		 * @private
+		 * @type {Map<string, number> | undefined}
+		 **/
 		this._sourceSizes = undefined;
-		/** @private @type {Set<string>} */
+		/**
+		 * @private
+		 * @type {undefined | SourceTypes}
+		 **/
 		this._sourceTypes = undefined;
 
 		// Cache
@@ -419,7 +443,7 @@ class NormalModule extends Module {
 		// TODO reconsider this for webpack 6
 		if (this.buildInfo) {
 			if (this._sourceTypes === undefined) this.getSourceTypes();
-			for (const type of this._sourceTypes) {
+			for (const type of /** @type {SourceTypes} */ (this._sourceTypes)) {
 				this.size(type);
 			}
 		}
@@ -433,15 +457,22 @@ class NormalModule extends Module {
 	/**
 	 * Module should be unsafe cached. Get data that's needed for that.
 	 * This data will be passed to restoreFromUnsafeCache later.
-	 * @returns {object} cached data
+	 * @returns {UnsafeCacheData} cached data
 	 */
 	getUnsafeCacheData() {
-		const data = super.getUnsafeCacheData();
+		const data =
+			/** @type {NormalModuleUnsafeCacheData} */
+			(super.getUnsafeCacheData());
 		data.parserOptions = this.parserOptions;
 		data.generatorOptions = this.generatorOptions;
 		return data;
 	}
 
+	/**
+	 * restore unsafe cache data
+	 * @param {NormalModuleUnsafeCacheData} unsafeCacheData data from getUnsafeCacheData
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory handling the unsafe caching
+	 */
 	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
 		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
 	}
@@ -466,8 +497,8 @@ class NormalModule extends Module {
 	/**
 	 * @param {string} context the compilation context
 	 * @param {string} name the asset name
-	 * @param {string} content the content
-	 * @param {string | TODO} sourceMap an optional source map
+	 * @param {string | Buffer} content the content
+	 * @param {(string | SourceMap)=} sourceMap an optional source map
 	 * @param {Object=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
@@ -493,7 +524,11 @@ class NormalModule extends Module {
 				return new SourceMapSource(
 					content,
 					name,
-					contextifySourceMap(context, sourceMap, associatedObjectForCache)
+					contextifySourceMap(
+						context,
+						/** @type {SourceMap} */ (sourceMap),
+						associatedObjectForCache
+					)
 				);
 			}
 		}
@@ -502,12 +537,14 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * @private
+	 * @template T
 	 * @param {ResolverWithOptions} resolver a resolver
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
 	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @returns {NormalModuleLoaderContext} loader context
+	 * @returns {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} loader context
 	 */
 	_createLoaderContext(resolver, options, compilation, fs, hooks) {
 		const { requestShortener } = compilation.runtimeTemplate;
@@ -516,16 +553,19 @@ class NormalModule extends Module {
 			if (!currentLoader) return "(not in loader scope)";
 			return requestShortener.shorten(currentLoader.loader);
 		};
+		/**
+		 * @returns {ResolveContext} resolve context
+		 */
 		const getResolveContext = () => {
 			return {
 				fileDependencies: {
-					add: d => loaderContext.addDependency(d)
+					add: d => /** @type {TODO} */ (loaderContext).addDependency(d)
 				},
 				contextDependencies: {
-					add: d => loaderContext.addContextDependency(d)
+					add: d => /** @type {TODO} */ (loaderContext).addContextDependency(d)
 				},
 				missingDependencies: {
-					add: d => loaderContext.addMissingDependency(d)
+					add: d => /** @type {TODO} */ (loaderContext).addMissingDependency(d)
 				}
 			};
 		};
@@ -542,26 +582,41 @@ class NormalModule extends Module {
 			contextify.bindContextCache(this.context, compilation.compiler.root)
 		);
 		const utils = {
+			/**
+			 * @param {string} context context
+			 * @param {string} request request
+			 * @returns {string} result
+			 */
 			absolutify: (context, request) => {
 				return context === this.context
 					? getAbsolutifyInContext()(request)
 					: getAbsolutify()(context, request);
 			},
+			/**
+			 * @param {string} context context
+			 * @param {string} request request
+			 * @returns {string} result
+			 */
 			contextify: (context, request) => {
 				return context === this.context
 					? getContextifyInContext()(request)
 					: getContextify()(context, request);
 			},
+			/**
+			 * @param {(string | typeof import("./util/Hash"))=} type type
+			 * @returns {Hash} hash
+			 */
 			createHash: type => {
 				return createHash(type || compilation.outputOptions.hashFunction);
 			}
 		};
+		/** @type {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} */
 		const loaderContext = {
 			version: 2,
 			getOptions: schema => {
 				const loader = this.getCurrentLoader(loaderContext);
 
-				let { options } = loader;
+				let { options } = /** @type {LoaderItem} */ (loader);
 
 				if (typeof options === "string") {
 					if (options.startsWith("{") && options.endsWith("}")) {
@@ -649,27 +704,39 @@ class NormalModule extends Module {
 				};
 			},
 			emitFile: (name, content, sourceMap, assetInfo) => {
-				if (!this.buildInfo.assets) {
-					this.buildInfo.assets = Object.create(null);
-					this.buildInfo.assetsInfo = new Map();
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+				if (!buildInfo.assets) {
+					buildInfo.assets = Object.create(null);
+					buildInfo.assetsInfo = new Map();
 				}
-				this.buildInfo.assets[name] = this.createSourceForAsset(
-					options.context,
+
+				const assets =
+					/** @type {NonNullable<KnownBuildInfo["assets"]>} */
+					(buildInfo.assets);
+				const assetsInfo =
+					/** @type {NonNullable<KnownBuildInfo["assetsInfo"]>} */
+					(buildInfo.assetsInfo);
+
+				assets[name] = this.createSourceForAsset(
+					/** @type {string} */ (options.context),
 					name,
 					content,
 					sourceMap,
 					compilation.compiler.root
 				);
-				this.buildInfo.assetsInfo.set(name, assetInfo);
+				assetsInfo.set(name, assetInfo);
 			},
 			addBuildDependency: dep => {
-				if (this.buildInfo.buildDependencies === undefined) {
-					this.buildInfo.buildDependencies = new LazySet();
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+				if (buildInfo.buildDependencies === undefined) {
+					buildInfo.buildDependencies = new LazySet();
 				}
-				this.buildInfo.buildDependencies.add(dep);
+				buildInfo.buildDependencies.add(dep);
 			},
 			utils,
-			rootContext: options.context,
+			rootContext: /** @type {string} */ (options.context),
 			webpack: true,
 			sourceMap: !!this.useSourceMap,
 			mode: options.mode || "production",
@@ -686,6 +753,12 @@ class NormalModule extends Module {
 		return loaderContext;
 	}
 
+	// TODO remove `loaderContext` in webpack@6
+	/**
+	 * @param {TODO} loaderContext loader context
+	 * @param {number} index index
+	 * @returns {LoaderItem | null} loader
+	 */
 	getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
 		if (
 			this.loaders &&
@@ -702,7 +775,7 @@ class NormalModule extends Module {
 	/**
 	 * @param {string} context the compilation context
 	 * @param {string | Buffer} content the content
-	 * @param {string | TODO} sourceMap an optional source map
+	 * @param {(string | SourceMapSource)=} sourceMap an optional source map
 	 * @param {Object=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
@@ -723,7 +796,11 @@ class NormalModule extends Module {
 			return new SourceMapSource(
 				content,
 				contextifySourceUrl(context, identifier, associatedObjectForCache),
-				contextifySourceMap(context, sourceMap, associatedObjectForCache)
+				contextifySourceMap(
+					context,
+					/** @type {TODO} */ (sourceMap),
+					associatedObjectForCache
+				)
 			);
 		}
 
@@ -791,7 +868,7 @@ class NormalModule extends Module {
 			}
 
 			this._source = this.createSource(
-				options.context,
+				/** @type {string} */ (options.context),
 				this.binary ? asBuffer(source) : asString(source),
 				sourceMap,
 				compilation.compiler.root
@@ -806,10 +883,12 @@ class NormalModule extends Module {
 			return callback();
 		};
 
-		this.buildInfo.fileDependencies = new LazySet();
-		this.buildInfo.contextDependencies = new LazySet();
-		this.buildInfo.missingDependencies = new LazySet();
-		this.buildInfo.cacheable = true;
+		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+		buildInfo.fileDependencies = new LazySet();
+		buildInfo.contextDependencies = new LazySet();
+		buildInfo.missingDependencies = new LazySet();
+		buildInfo.cacheable = true;
 
 		try {
 			hooks.beforeLoaders.call(this.loaders, this, loaderContext);
@@ -819,7 +898,8 @@ class NormalModule extends Module {
 		}
 
 		if (this.loaders.length > 0) {
-			this.buildInfo.buildDependencies = new LazySet();
+			/** @type {BuildInfo} */
+			(this.buildInfo).buildDependencies = new LazySet();
 		}
 
 		runLoaders(
@@ -850,19 +930,37 @@ class NormalModule extends Module {
 						undefined;
 
 				if (!result) {
-					this.buildInfo.cacheable = false;
+					/** @type {BuildInfo} */
+					(this.buildInfo).cacheable = false;
 					return processResult(
 						err || new Error("No result from loader-runner processing"),
 						null
 					);
 				}
-				this.buildInfo.fileDependencies.addAll(result.fileDependencies);
-				this.buildInfo.contextDependencies.addAll(result.contextDependencies);
-				this.buildInfo.missingDependencies.addAll(result.missingDependencies);
+
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
+				const fileDependencies =
+					/** @type {NonNullable<KnownBuildInfo["fileDependencies"]>} */
+					(buildInfo.fileDependencies);
+				const contextDependencies =
+					/** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+					(buildInfo.contextDependencies);
+				const missingDependencies =
+					/** @type {NonNullable<KnownBuildInfo["missingDependencies"]>} */
+					(buildInfo.missingDependencies);
+
+				fileDependencies.addAll(result.fileDependencies);
+				contextDependencies.addAll(result.contextDependencies);
+				missingDependencies.addAll(result.missingDependencies);
 				for (const loader of this.loaders) {
-					this.buildInfo.buildDependencies.add(loader.loader);
+					const buildDependencies =
+						/** @type {NonNullable<KnownBuildInfo["buildDependencies"]>} */
+						(buildInfo.buildDependencies);
+
+					buildDependencies.add(loader.loader);
 				}
-				this.buildInfo.cacheable = this.buildInfo.cacheable && result.cacheable;
+				buildInfo.cacheable = buildInfo.cacheable && result.cacheable;
 				processResult(err, result.result);
 			}
 		);
@@ -879,6 +977,11 @@ class NormalModule extends Module {
 		this.addError(error);
 	}
 
+	/**
+	 * @param {TODO} rule rule
+	 * @param {string} content content
+	 * @returns {boolean} result
+	 */
 	applyNoParseRule(rule, content) {
 		// must start with "rule" if rule is a string
 		if (typeof rule === "string") {
@@ -892,9 +995,11 @@ class NormalModule extends Module {
 		return rule.test(content);
 	}
 
-	// check if module should not be parsed
-	// returns "true" if the module should !not! be parsed
-	// returns "false" if the module !must! be parsed
+	/**
+	 * @param {TODO} noParseRule no parse rule
+	 * @param {string} request request
+	 * @returns {boolean} check if module should not be parsed, returns "true" if the module should !not! be parsed, returns "false" if the module !must! be parsed
+	 */
 	shouldPreventParsing(noParseRule, request) {
 		// if no noParseRule exists, return false
 		// the module !must! be parsed.
@@ -920,6 +1025,10 @@ class NormalModule extends Module {
 		return false;
 	}
 
+	/**
+	 * @param {Compilation} compilation compilation
+	 * @private
+	 */
 	_initBuildHash(compilation) {
 		const hash = createHash(compilation.outputOptions.hashFunction);
 		if (this._source) {
@@ -928,7 +1037,8 @@ class NormalModule extends Module {
 		}
 		hash.update("meta");
 		hash.update(JSON.stringify(this.buildMeta));
-		this.buildInfo.hash = /** @type {string} */ (hash.digest("hex"));
+		/** @type {BuildInfo} */
+		(this.buildInfo).hash = /** @type {string} */ (hash.digest("hex"));
 	}
 
 	/**
@@ -974,10 +1084,18 @@ class NormalModule extends Module {
 				return callback();
 			}
 
+			/**
+			 * @param {Error} e error
+			 * @returns {void}
+			 */
 			const handleParseError = e => {
-				const source = this._source.source();
+				const source = /** @type {Source} */ (this._source).source();
 				const loaders = this.loaders.map(item =>
-					contextify(options.context, item.loader, compilation.compiler.root)
+					contextify(
+						/** @type {string} */ (options.context),
+						item.loader,
+						compilation.compiler.root
+					)
 				);
 				const error = new ModuleParseError(source, e, loaders, this.type);
 				this.markModuleAsErrored(error);
@@ -985,7 +1103,7 @@ class NormalModule extends Module {
 				return callback();
 			};
 
-			const handleParseResult = result => {
+			const handleParseResult = () => {
 				this.dependencies.sort(
 					concatComparators(
 						compareSelect(a => a.loc, compareLocations),
@@ -993,7 +1111,9 @@ class NormalModule extends Module {
 					)
 				);
 				this._initBuildHash(compilation);
-				this._lastSuccessfulBuildMeta = this.buildMeta;
+				this._lastSuccessfulBuildMeta =
+					/** @type {BuildMeta} */
+					(this.buildMeta);
 				return handleBuildDone();
 			};
 
@@ -1006,12 +1126,17 @@ class NormalModule extends Module {
 				}
 
 				const snapshotOptions = compilation.options.snapshot.module;
-				if (!this.buildInfo.cacheable || !snapshotOptions) {
+				const { cacheable } = /** @type {BuildInfo} */ (this.buildInfo);
+				if (!cacheable || !snapshotOptions) {
 					return callback();
 				}
 				// add warning for all non-absolute paths in fileDependencies, etc
 				// This makes it easier to find problems with watching and/or caching
+				/** @type {undefined | Set<string>} */
 				let nonAbsoluteDependencies = undefined;
+				/**
+				 * @param {LazySet<string>} deps deps
+				 */
 				const checkDependencies = deps => {
 					for (const dep of deps) {
 						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
@@ -1028,7 +1153,11 @@ class NormalModule extends Module {
 								);
 								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
 									(depWithoutGlob !== dep
-										? this.buildInfo.contextDependencies
+										? /** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+											(
+												/** @type {BuildInfo} */ (this.buildInfo)
+													.contextDependencies
+											)
 										: deps
 									).add(absolute);
 								}
@@ -1038,9 +1167,19 @@ class NormalModule extends Module {
 						}
 					}
 				};
-				checkDependencies(this.buildInfo.fileDependencies);
-				checkDependencies(this.buildInfo.missingDependencies);
-				checkDependencies(this.buildInfo.contextDependencies);
+				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+				const fileDependencies =
+					/** @type {NonNullable<KnownBuildInfo["fileDependencies"]>} */
+					(buildInfo.fileDependencies);
+				const contextDependencies =
+					/** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+					(buildInfo.contextDependencies);
+				const missingDependencies =
+					/** @type {NonNullable<KnownBuildInfo["missingDependencies"]>} */
+					(buildInfo.missingDependencies);
+				checkDependencies(fileDependencies);
+				checkDependencies(missingDependencies);
+				checkDependencies(contextDependencies);
 				if (nonAbsoluteDependencies !== undefined) {
 					const InvalidDependenciesModuleWarning =
 						getInvalidDependenciesModuleWarning();
@@ -1051,19 +1190,19 @@ class NormalModule extends Module {
 				// convert file/context/missingDependencies into filesystem snapshot
 				compilation.fileSystemInfo.createSnapshot(
 					startTime,
-					this.buildInfo.fileDependencies,
-					this.buildInfo.contextDependencies,
-					this.buildInfo.missingDependencies,
+					fileDependencies,
+					contextDependencies,
+					missingDependencies,
 					snapshotOptions,
 					(err, snapshot) => {
 						if (err) {
 							this.markModuleAsErrored(err);
 							return;
 						}
-						this.buildInfo.fileDependencies = undefined;
-						this.buildInfo.contextDependencies = undefined;
-						this.buildInfo.missingDependencies = undefined;
-						this.buildInfo.snapshot = snapshot;
+						buildInfo.fileDependencies = undefined;
+						buildInfo.contextDependencies = undefined;
+						buildInfo.missingDependencies = undefined;
+						buildInfo.snapshot = snapshot;
 						return callback();
 					}
 				);
@@ -1082,15 +1221,16 @@ class NormalModule extends Module {
 			const noParseRule = options.module && options.module.noParse;
 			if (this.shouldPreventParsing(noParseRule, this.request)) {
 				// We assume that we need module and exports
-				this.buildInfo.parsed = false;
+				/** @type {BuildInfo} */
+				(this.buildInfo).parsed = false;
 				this._initBuildHash(compilation);
 				return handleBuildDone();
 			}
 
-			let result;
 			try {
-				const source = this._source.source();
-				result = this.parser.parse(this._ast || source, {
+				const source = /** @type {Source} */ (this._source).source();
+				/** @type {Parser} */
+				(this.parser).parse(this._ast || source, {
 					source,
 					current: this,
 					module: this,
@@ -1098,10 +1238,10 @@ class NormalModule extends Module {
 					options: options
 				});
 			} catch (e) {
-				handleParseError(e);
+				handleParseError(/** @type {Error} */ (e));
 				return;
 			}
-			handleParseResult(result);
+			handleParseResult();
 		});
 	}
 
@@ -1110,7 +1250,9 @@ class NormalModule extends Module {
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
 	getConcatenationBailoutReason(context) {
-		return this.generator.getConcatenationBailoutReason(this, context);
+		return /** @type {Generator} */ (
+			this.generator
+		).getConcatenationBailoutReason(this, context);
 	}
 
 	/**
@@ -1162,11 +1304,13 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		if (this._sourceTypes === undefined) {
-			this._sourceTypes = this.generator.getTypes(this);
+			this._sourceTypes = /** @type {Generator} */ (this.generator).getTypes(
+				this
+			);
 		}
 		return this._sourceTypes;
 	}
@@ -1189,7 +1333,9 @@ class NormalModule extends Module {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
 
-		if (!this.buildInfo.parsed) {
+		const { parsed } = /** @type {BuildInfo} */ (this.buildInfo);
+
+		if (!parsed) {
 			runtimeRequirements.add(RuntimeGlobals.module);
 			runtimeRequirements.add(RuntimeGlobals.exports);
 			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
@@ -1261,15 +1407,16 @@ class NormalModule extends Module {
 		// always try to build in case of an error
 		if (this.error) return callback(null, true);
 
+		const { cacheable, snapshot, valueDependencies } =
+			/** @type {BuildInfo} */ (this.buildInfo);
+
 		// always build when module is not cacheable
-		if (!this.buildInfo.cacheable) return callback(null, true);
+		if (!cacheable) return callback(null, true);
 
 		// build when there is no snapshot to check
-		if (!this.buildInfo.snapshot) return callback(null, true);
+		if (!snapshot) return callback(null, true);
 
 		// build when valueDependencies have changed
-		/** @type {Map<string, string | Set<string>>} */
-		const valueDependencies = this.buildInfo.valueDependencies;
 		if (valueDependencies) {
 			if (!valueCacheVersions) return callback(null, true);
 			for (const [key, value] of valueDependencies) {
@@ -1288,7 +1435,7 @@ class NormalModule extends Module {
 		}
 
 		// check snapshot for validity
-		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
+		fileSystemInfo.checkSnapshotValid(snapshot, (err, valid) => {
 			if (err) return callback(err);
 			if (!valid) return callback(null, true);
 			const hooks = NormalModule.getCompilationHooks(compilation);
@@ -1316,7 +1463,10 @@ class NormalModule extends Module {
 		if (cachedSize !== undefined) {
 			return cachedSize;
 		}
-		const size = Math.max(1, this.generator.getSize(this, type));
+		const size = Math.max(
+			1,
+			/** @type {Generator} */ (this.generator).getSize(this, type)
+		);
 		if (this._sourceSizes === undefined) {
 			this._sourceSizes = new Map();
 		}
@@ -1336,7 +1486,8 @@ class NormalModule extends Module {
 		missingDependencies,
 		buildDependencies
 	) {
-		const { snapshot, buildDependencies: buildDeps } = this.buildInfo;
+		const { snapshot, buildDependencies: buildDeps } =
+			/** @type {BuildInfo} */ (this.buildInfo);
 		if (snapshot) {
 			fileDependencies.addAll(snapshot.getFileIterable());
 			contextDependencies.addAll(snapshot.getContextIterable());
@@ -1346,7 +1497,7 @@ class NormalModule extends Module {
 				fileDependencies: fileDeps,
 				contextDependencies: contextDeps,
 				missingDependencies: missingDeps
-			} = this.buildInfo;
+			} = /** @type {BuildInfo} */ (this.buildInfo);
 			if (fileDeps !== undefined) fileDependencies.addAll(fileDeps);
 			if (contextDeps !== undefined) contextDependencies.addAll(contextDeps);
 			if (missingDeps !== undefined) missingDependencies.addAll(missingDeps);
@@ -1362,7 +1513,7 @@ class NormalModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.buildInfo.hash);
+		hash.update(/** @type {BuildInfo} */ (this.buildInfo).hash);
 		this.generator.updateHash(hash, {
 			module: this,
 			...context