@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/NormalModule.js

@@ -23,13 +23,8 @@ const Module = require("./Module");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
+const HarmonyImportSideEffectDependency = require("./dependencies/HarmonyImportSideEffectDependency");
 const HookWebpackError = require("./errors/HookWebpackError");
-const ModuleBuildError = require("./errors/ModuleBuildError");
-const ModuleError = require("./errors/ModuleError");
-const ModuleParseError = require("./errors/ModuleParseError");
-const ModuleWarning = require("./errors/ModuleWarning");
-const NonErrorEmittedError = require("./errors/NonErrorEmittedError");
-const UnhandledSchemeError = require("./errors/UnhandledSchemeError");
 const {
 	createLoaderContext,
 	getContext,
@@ -52,63 +47,107 @@ const {
 	ABSOLUTE_PATH_REGEXP,
 	absolutify,
 	contextify,
-	makePathsRelative
+	contextifySourceUrl
 } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
 const parseJson = require("./util/parseJson");
 
-/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./Generator")} Generator */
-/** @typedef {import("./Generator").GenerateErrorFn} GenerateErrorFn */
-/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */
-/** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
-/** @typedef {import("./Module").BuildMeta} BuildMeta */
-/** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
-/** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
-/** @typedef {import("./Module").KnownBuildInfo} KnownBuildInfo */
-/** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("./Module").LibIdent} LibIdent */
-/** @typedef {import("./Module").NameForCondition} NameForCondition */
-/** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("./Module").NeedBuildCallback} NeedBuildCallback */
-/** @typedef {import("./Module").BuildCallback} BuildCallback */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./Module").Sources} Sources */
-/** @typedef {import("./Module").SourceType} SourceType */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
-/** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
-/** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */
-/** @typedef {import("./NormalModuleFactory").ParserByType} ParserByType */
-/** @typedef {import("./NormalModuleFactory").ParserOptionsByType} ParserOptionsByType */
-/** @typedef {import("./NormalModuleFactory").GeneratorByType} GeneratorByType */
-/** @typedef {import("./NormalModuleFactory").GeneratorOptionsByType} GeneratorOptionsByType */
-/** @typedef {import("./NormalModuleFactory").ResourceSchemeData} ResourceSchemeData */
-/** @typedef {import("./Parser")} Parser */
-/** @typedef {import("./Parser").PreparsedAst} PreparsedAst */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
+const getValidate = memoize(() => require("schema-utils").validate);
+
+const getGenerator = memoize(() => require("./Generator"));
+
+const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));
+
+const getInvalidDependenciesModuleWarning = memoize(() =>
+	require("./errors/InvalidDependenciesModuleWarning")
+);
+
+const getUnhandledSchemeError = memoize(() =>
+	require("./errors/UnhandledSchemeError")
+);
+
+const getNonErrorEmittedError = memoize(() =>
+	require("./errors/NonErrorEmittedError")
+);
+
+const getModuleWarning = memoize(() => require("./errors/ModuleWarning"));
+
+const getModuleParseError = memoize(() => require("./errors/ModuleParseError"));
+
+const getModuleError = memoize(() => require("./errors/ModuleError"));
+
+const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
+
+/** @import { ResolveContext, ResolveRequest } from "enhanced-resolve" */
+/** @import { Source, RawSourceMap } from "webpack-sources" */
+/**
+ * @import {
+ * 	ResolveOptions,
+ * 	NoParse,
+ * 	HashFunction
+ * } from "../declarations/WebpackOptions"
+ */
+/**
+ * @import Compilation, {
+ * 	FileSystemDependencies,
+ * 	UnsafeCacheData
+ * } from "./Compilation"
+ */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "./config/defaults"
+ */
+/** @import { UpdateHashContext } from "./Dependency" */
+/** @import Generator, { GenerateErrorFn } from "./Generator" */
+/** @import { Snapshot } from "./FileSystemInfo" */
+/**
+ * @import {
+ * 	BuildInfo,
+ * 	ValueCacheVersions,
+ * 	BuildMeta,
+ * 	CodeGenerationContext,
+ * 	CodeGenerationResult,
+ * 	CodeGenerationResultData,
+ * 	ConcatenationBailoutReasonContext,
+ * 	KnownBuildInfo,
+ * 	LibIdentOptions,
+ * 	LibIdent,
+ * 	NameForCondition,
+ * 	NeedBuildContext,
+ * 	NeedBuildCallback,
+ * 	BuildCallback,
+ * 	RuntimeRequirements,
+ * 	Sources,
+ * 	SourceType,
+ * 	SourceTypes
+ * } from "./Module"
+ */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import { ConnectionState } from "./ModuleGraphConnection" */
+/**
+ * @import NormalModuleFactory, {
+ * 	NormalModuleTypes,
+ * 	ParserByType,
+ * 	ParserOptionsByType,
+ * 	GeneratorByType,
+ * 	GeneratorOptionsByType,
+ * 	ResourceSchemeData
+ * } from "./NormalModuleFactory"
+ */
+/** @import Parser, { PreparsedAst } from "./Parser" */
+/** @import RequestShortener from "./RequestShortener" */
+/** @import { ResolverWithOptions } from "./ResolverFactory" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "./serialization/ObjectMiddleware"
+ */
+/** @import Hash from "./util/Hash" */
+/** @import { InputFileSystem } from "./util/fs" */
+/** @import { AssociatedObjectForCache } from "./util/identifier" */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook
@@ -129,18 +168,6 @@ const parseJson = require("./util/parseJson");
 
 /** @typedef {(content: string) => boolean} NoParseFn */
 
-const getInvalidDependenciesModuleWarning = memoize(() =>
-	require("./errors/InvalidDependenciesModuleWarning")
-);
-
-const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));
-
-const getValidate = memoize(() => require("schema-utils").validate);
-
-const getHarmonyImportSideEffectDependency = memoize(() =>
-	require("./dependencies/HarmonyImportSideEffectDependency")
-);
-
 /**
  * @param {NormalModule} mod the module
  * @param {ModuleGraph} moduleGraph the module graph
@@ -391,21 +418,6 @@ const walkSideEffects = (rootMod, moduleGraph, SideEffectDep) => {
  * @property {string | null=} type
  */
 
-/**
- * @param {string} context absolute context path
- * @param {string} source a source path
- * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} new source path
- */
-const contextifySourceUrl = (context, source, associatedObjectForCache) => {
-	if (source.startsWith("webpack://")) return source;
-	return `webpack://${makePathsRelative(
-		context,
-		source,
-		associatedObjectForCache
-	)}`;
-};
-
 /**
  * @param {string} context absolute context path
  * @param {string | RawSourceMap} sourceMap a source map
@@ -471,16 +483,79 @@ const asBuffer = (input) => {
  * @typedef {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} DeprecatedReadResourceForScheme
  */
 
+const createCompilationHooks = () => {
+	/** @type {HookMap<AsyncSeriesBailHook<[AnyLoaderContext], string | Buffer | null>>} */
+	const readResource = new HookMap(
+		() => new AsyncSeriesBailHook(["loaderContext"])
+	);
+	return {
+		// TODO webpack 6 deprecate
+		/**
+		 * @deprecated Use the `readResource` hook instead.
+		 * @type {DeprecatedReadResourceForScheme}
+		 */
+		readResourceForScheme: new HookMap((scheme) => {
+			const hook = readResource.for(scheme);
+			return createFakeHook(
+				/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
+					tap: (options, fn) =>
+						hook.tap(options, (loaderContext) =>
+							fn(
+								loaderContext.resource,
+								/** @type {NormalModule} */ (loaderContext._module)
+							)
+						),
+					tapAsync: (options, fn) =>
+						hook.tapAsync(options, (loaderContext, callback) =>
+							fn(
+								loaderContext.resource,
+								/** @type {NormalModule} */ (loaderContext._module),
+								callback
+							)
+						),
+					tapPromise: (options, fn) =>
+						hook.tapPromise(options, (loaderContext) =>
+							fn(
+								loaderContext.resource,
+								/** @type {NormalModule} */ (loaderContext._module)
+							)
+						)
+				})
+			);
+		}),
+		/**
+		 * @since 5.58.0
+		 */
+		readResource,
+		/** @type {SyncHook<[AnyLoaderContext, NormalModule]>} */
+		loader: new SyncHook(["loaderContext", "module"]),
+		/** @type {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} */
+		beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
+		/**
+		 * @type {SyncHook<[NormalModule]>}
+		 * @since 5.59.0
+		 */
+		beforeParse: new SyncHook(["module"]),
+		/**
+		 * @type {SyncHook<[NormalModule]>}
+		 * @since 5.59.0
+		 */
+		beforeSnapshot: new SyncHook(["module"]),
+		/**
+		 * @type {SyncWaterfallHook<[Result, NormalModule]>}
+		 * @since 5.99.0
+		 */
+		processResult: new SyncWaterfallHook(["result", "module"]),
+		/**
+		 * @type {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>}
+		 * @since 5.49.0
+		 */
+		needBuild: new AsyncSeriesBailHook(["module", "context"])
+	};
+};
+
 /**
- * @typedef {object} NormalModuleCompilationHooks
- * @property {SyncHook<[AnyLoaderContext, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} beforeLoaders
- * @property {SyncHook<[NormalModule]>} beforeParse
- * @property {SyncHook<[NormalModule]>} beforeSnapshot
- * @property {DeprecatedReadResourceForScheme} readResourceForScheme
- * @property {HookMap<AsyncSeriesBailHook<[AnyLoaderContext], string | Buffer | null>>} readResource
- * @property {SyncWaterfallHook<[Result, NormalModule]>} processResult
- * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
+ * @typedef {ReturnType<typeof createCompilationHooks>} NormalModuleCompilationHooks
  */
 
 /**
@@ -518,58 +593,13 @@ const asBuffer = (input) => {
  * @property {FileSystemDependencies=} missingDependencies
  * @property {FileSystemDependencies=} buildDependencies
  * @property {ValueCacheVersions=} valueDependencies
- * @property {(Snapshot | null)=} snapshot
+ * @property {(InstanceType<Snapshot> | null)=} snapshot
  * @property {string=} resourceIntegrity using in HttpUriPlugin
  */
 
 /** @typedef {BuildInfo & KnownNormalModuleBuildInfo} NormalModuleBuildInfo */
 
-const normalModuleHooksRegistry = createHooksRegistry(() => {
-	// TODO webpack 6 deprecate
-	/** @type {Partial<NormalModuleCompilationHooks>} */
-	const hooks = {};
-	hooks.readResourceForScheme = new HookMap((scheme) => {
-		const hook =
-			/** @type {NormalModuleCompilationHooks} */
-			(hooks).readResource.for(scheme);
-		return createFakeHook(
-			/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
-				tap: (options, fn) =>
-					hook.tap(options, (loaderContext) =>
-						fn(
-							loaderContext.resource,
-							/** @type {NormalModule} */ (loaderContext._module)
-						)
-					),
-				tapAsync: (options, fn) =>
-					hook.tapAsync(options, (loaderContext, callback) =>
-						fn(
-							loaderContext.resource,
-							/** @type {NormalModule} */ (loaderContext._module),
-							callback
-						)
-					),
-				tapPromise: (options, fn) =>
-					hook.tapPromise(options, (loaderContext) =>
-						fn(
-							loaderContext.resource,
-							/** @type {NormalModule} */ (loaderContext._module)
-						)
-					)
-			})
-		);
-	});
-	hooks.readResource = new HookMap(
-		() => new AsyncSeriesBailHook(["loaderContext"])
-	);
-	hooks.loader = new SyncHook(["loaderContext", "module"]);
-	hooks.beforeLoaders = new SyncHook(["loaders", "module", "loaderContext"]);
-	hooks.beforeParse = new SyncHook(["module"]);
-	hooks.beforeSnapshot = new SyncHook(["module"]);
-	hooks.processResult = new SyncWaterfallHook(["result", "module"]);
-	hooks.needBuild = new AsyncSeriesBailHook(["module", "context"]);
-	return /** @type {NormalModuleCompilationHooks} */ (hooks);
-});
+const normalModuleHooksRegistry = createHooksRegistry(createCompilationHooks);
 
 class NormalModule extends Module {
 	/**
@@ -651,6 +681,12 @@ class NormalModule extends Module {
 		 * @type {Source | null}
 		 */
 		this._source = null;
+		// Set at build time; declared here so the instance shape is fixed at construction
+		/**
+		 * @private
+		 * @type {PreparsedAst | null}
+		 */
+		this._ast = null;
 		/**
 		 * @private
 		 * @type {Map<undefined | SourceType, number> | undefined}
@@ -806,6 +842,29 @@ class NormalModule extends Module {
 		this._sideEffectsStateValue = undefined;
 	}
 
+	/**
+	 * Releases the cached parser between incremental rebuilds so it doesn't keep
+	 * the previous compilation alive.
+	 * @returns {void}
+	 */
+	_cleanupParserForCache() {
+		this.parser = undefined;
+	}
+
+	/**
+	 * Re-acquire factory-derived helpers (parser/generator) for an incremental
+	 * rebuild so this compilation's plugin hooks apply.
+	 * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+	 * @returns {void}
+	 */
+	_restoreParserAndGenerator(normalModuleFactory) {
+		this.parser = normalModuleFactory.getParser(this.type, this.parserOptions);
+		this.generator = normalModuleFactory.getGenerator(
+			this.type,
+			this.generatorOptions
+		);
+	}
+
 	/**
 	 * Module should be unsafe cached. Get data that's needed for that.
 	 * This data will be passed to restoreFromUnsafeCache later.
@@ -1027,10 +1086,10 @@ class NormalModule extends Module {
 			/** @type {LoaderContext<EXPECTED_ANY>["emitWarning"]} */
 			emitWarning: (warning) => {
 				if (!(warning instanceof Error)) {
-					warning = new NonErrorEmittedError(warning);
+					warning = new (getNonErrorEmittedError())(warning);
 				}
 				this.addWarning(
-					new ModuleWarning(warning, {
+					new (getModuleWarning())(warning, {
 						from: getCurrentLoaderName()
 					})
 				);
@@ -1038,10 +1097,10 @@ class NormalModule extends Module {
 			/** @type {LoaderContext<EXPECTED_ANY>["emitError"]} */
 			emitError: (error) => {
 				if (!(error instanceof Error)) {
-					error = new NonErrorEmittedError(error);
+					error = new (getNonErrorEmittedError())(error);
 				}
 				this.addError(
-					new ModuleError(error, {
+					new (getModuleError())(error, {
 						from: getCurrentLoaderName()
 					})
 				);
@@ -1234,10 +1293,10 @@ class NormalModule extends Module {
 		const processResult = (err, result_) => {
 			if (err) {
 				if (!(err instanceof Error)) {
-					err = new NonErrorEmittedError(err);
+					err = new (getNonErrorEmittedError())(err);
 				}
 				const currentLoader = this.getCurrentLoader(loaderContext);
-				const error = new ModuleBuildError(err, {
+				const error = new (getModuleBuildError())(err, {
 					from:
 						currentLoader &&
 						compilation.runtimeTemplate.requestShortener.shorten(
@@ -1266,7 +1325,7 @@ class NormalModule extends Module {
 							: "unknown"
 					}) didn't return a Buffer or String`
 				);
-				const error = new ModuleBuildError(err);
+				const error = new (getModuleBuildError())(err);
 				return callback(error);
 			}
 
@@ -1340,7 +1399,7 @@ class NormalModule extends Module {
 									} else {
 										if (typeof result !== "string" && !result) {
 											return reject(
-												new UnhandledSchemeError(
+												new (getUnhandledSchemeError())(
 													/** @type {string} */
 													(scheme),
 													resourcePath
@@ -1388,7 +1447,9 @@ class NormalModule extends Module {
 								);
 								return callback(null, source, sourceMap);
 							} catch (err) {
-								this.addWarning(new ModuleWarning(/** @type {Error} */ (err)));
+								this.addWarning(
+									new (getModuleWarning())(/** @type {Error} */ (err))
+								);
 								return callback(null, result);
 							}
 						}
@@ -1566,7 +1627,8 @@ class NormalModule extends Module {
 			pureFunctions: undefined,
 			inlineExports: undefined,
 			moduleConcatenationBailout: undefined,
-			needCreateRequire: undefined
+			needCreateRequire: undefined,
+			usesTopLevelUsingDeclaration: undefined
 		};
 
 		const startTime = compilation.compiler.fsStartTime || Date.now();
@@ -1590,7 +1652,12 @@ class NormalModule extends Module {
 				const loaders = this.loaders.map((item) =>
 					contextify(options.context, item.loader, compilation.compiler.root)
 				);
-				const error = new ModuleParseError(source, e, loaders, this.type);
+				const error = new (getModuleParseError())(
+					source,
+					e,
+					loaders,
+					this.type
+				);
 				this.markModuleAsErrored(error);
 				this._initBuildHash(compilation);
 				return callback();
@@ -1770,7 +1837,7 @@ class NormalModule extends Module {
 		return walkSideEffects(
 			this,
 			moduleGraph,
-			getHarmonyImportSideEffectDependency()
+			HarmonyImportSideEffectDependency
 		);
 	}
 
@@ -1848,9 +1915,7 @@ class NormalModule extends Module {
 							getData,
 							type
 						})
-					: new RawSource(
-							`throw new Error(${JSON.stringify(this.error.message)});`
-						)
+					: new RawSource(getGenerator().throwBuildErrorCode(this.error))
 				: generator.generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,