@depup/webpack 5.111.1-depup.1 → 5.112.0-depup.0

package/lib/optimize/ConcatenatedModule.js

@@ -11,26 +11,19 @@ const {
 	ConcatSource,
 	ReplaceSource
 } = require("webpack-sources");
-const ConcatenationScope = require("../ConcatenationScope");
-const Dependency = require("../Dependency");
-const { UsageState } = require("../ExportsInfo");
-const ExternalModule = require("../ExternalModule");
-const Module = require("../Module");
-const {
-	JAVASCRIPT_TYPE,
-	JAVASCRIPT_TYPES
-} = require("../ModuleSourceTypeConstants");
-const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../ModuleTypeConstants");
-const NormalModule = require("../NormalModule");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
 const { DEFAULTS } = require("../config/defaults");
-const CommonJsExportRequireDependency = require("../dependencies/CommonJsExportRequireDependency");
-const CommonJsFullRequireDependency = require("../dependencies/CommonJsFullRequireDependency");
-const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
-const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
+const { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
+const Dependency = require("../graph/Dependency");
+const { UsageState } = require("../graph/ExportsInfo");
+const isDependencyKind = require("../graph/isDependencyKind");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const analyzeScope = require("../javascript/ScopeAnalyzer");
+const Module = require("../module/Module");
+const {
+	JAVASCRIPT_TYPE,
+	JAVASCRIPT_TYPES
+} = require("../module/ModuleSourceTypeConstants");
+const { JAVASCRIPT_MODULE_TYPE_ESM } = require("../module/ModuleTypeConstants");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
@@ -38,6 +31,8 @@ const {
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const Template = require("../template/Template");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
 const { getBuildDiagnostics } = require("../util/buildDiagnostics");
@@ -50,7 +45,6 @@ const {
 	addScopeSymbols,
 	findNewName,
 	getAllReferences,
-	getPathInAst,
 	getUsedNamesInScopeInfo,
 	isCommonJsConcatenationEnabled
 } = require("../util/concatenate");
@@ -67,7 +61,8 @@ const {
 	runtimeConditionToString,
 	subtractRuntimeCondition
 } = require("../util/runtime");
-const { InlinedUsedName } = require("./InlineExports");
+const ConcatenationScope = require("./ConcatenationScope");
+const { isInlinedUsedName } = require("./InlineExports");
 
 /** @import { Source } from "webpack-sources" */
 /**
@@ -75,13 +70,13 @@ const { InlinedUsedName } = require("./InlineExports");
  * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
  * } from "../config/defaults"
  */
-/** @import ChunkGraph from "../ChunkGraph" */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compilation, { FileSystemDependencies } from "../Compilation" */
-/** @import { UpdateHashContext } from "../Dependency" */
-/** @import HarmonyImportDependency from "../dependencies/HarmonyImportDependency" */
-/** @import DependencyTemplates from "../DependencyTemplates" */
-/** @import { ExportInfo } from "../ExportsInfo" */
+/** @import { UpdateHashContext } from "../graph/Dependency" */
+/** @import ESMImportDependency from "../dependencies/esm/ESMImportDependency" */
+/** @import DependencyTemplates from "../template/DependencyTemplates" */
+/** @import { ExportInfo } from "../graph/ExportsInfo" */
 /**
  * @import {
  * 	BuildCallback,
@@ -96,18 +91,19 @@ const { InlinedUsedName } = require("./InlineExports");
  * 	NameForCondition,
  * 	ReadOnlyRuntimeRequirements,
  * 	RuntimeRequirements,
- * 	SourceTypes
- * } from "../Module"
+ * 	SourceTypes,
+ * 	ModuleKinds
+ * } from "../module/Module"
  */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
- * } from "../ModuleGraphConnection"
+ * } from "../graph/ModuleGraphConnection"
  */
-/** @import RequestShortener from "../RequestShortener" */
-/** @import { ResolverWithOptions } from "../ResolverFactory" */
-/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import { ResolverWithOptions } from "../resolve/ResolverFactory" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo,
@@ -130,12 +126,12 @@ const { InlinedUsedName } = require("./InlineExports");
  */
 /** @import Hash, { HashFunction } from "../util/Hash" */
 /** @import { UsedNames, UsedNamesInScopeInfo } from "../util/concatenate" */
-/** @import { InputFileSystem } from "../util/fs" */
+/** @import { InputFileSystem } from "../fs/fs" */
 /** @import { AssociatedObjectForCache } from "../util/identifier" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @template T
- * @typedef {import("../InitFragment")<T>} InitFragment
+ * @typedef {import("../template/InitFragment")<T>} InitFragment
  */
 
 /**
@@ -206,7 +202,7 @@ const findIdentifiers = (source) => {
  * @property {boolean} eager a wrapped body reached by an eager import edge, so its accessor is called at its own slot in evaluation order
  * @property {Module} module
  * @property {number} index
- * @property {Program | undefined} ast
+ * @property {Set<number> | undefined} shorthandIdentifierStarts where each shorthand property's identifier starts
  * @property {Source | undefined} internalSource
  * @property {ReplaceSource | undefined} source
  * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
@@ -303,6 +299,7 @@ const compareNumbers = (a, b) => {
 
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
+const byDependencyIndex = createComparator("dependencyIndex", compareNumbers);
 
 /**
  * @param {Iterable<string>} iterable iterable object
@@ -357,7 +354,7 @@ const subtractNonDeferAccess = (a, b) => a && !b;
  * @returns {boolean} true, when the module renders wrapped
  */
 const needWrapped = (module) =>
-	module instanceof NormalModule &&
+	module.is("normal") &&
 	module.type.startsWith("javascript/") &&
 	module.buildMeta !== undefined &&
 	module.buildMeta.exportsType !== "namespace";
@@ -367,11 +364,14 @@ const needWrapped = (module) =>
  * @param {ConcatenationEntry} entry a member of the concatenation
  * @returns {boolean} true, when it may be wrapped
  */
-const entryCanBeWrapped = (entry) =>
-	(entry.module instanceof NormalModule &&
-		!entry.module.type.startsWith("css/")) ||
-	(entry.module instanceof ExternalModule &&
-		entry.module.canBeWrappedInConcatenation());
+const entryCanBeWrapped = (entry) => {
+	// TODO in the next major release: call it directly. A module built against an older webpack
+	// extends a base class without it, so fall back to the check this replaced.
+	if (typeof entry.module.canBeWrappedInConcatenation !== "function") {
+		return !entry.module.type.startsWith("css/");
+	}
+	return entry.module.canBeWrappedInConcatenation();
+};
 
 /** @typedef {Set<ConcatenatedModuleInfo>} NeededNamespaceObjects */
 
@@ -756,7 +756,7 @@ const getFinalBinding = (
 						exportName
 					};
 				}
-				if (usedName instanceof InlinedUsedName) {
+				if (isInlinedUsedName(usedName)) {
 					return {
 						info,
 						// Render the inlined literal only, not its property suffix: that
@@ -798,7 +798,7 @@ const getFinalBinding = (
 					const usedName = moduleGraph
 						.getExportsInfo(target.module)
 						.getUsedName([...target.export, ...exportName.slice(1)], runtime);
-					if (usedName instanceof InlinedUsedName) {
+					if (isInlinedUsedName(usedName)) {
 						return {
 							info,
 							// Literal only; suffix is appended once via `ids` (see directExport branch).
@@ -821,9 +821,16 @@ const getFinalBinding = (
 							` * ${info.type} ${m.readableIdentifier(requestShortener)}`
 					).join("\n")}`
 				);
-			}
-			if (reexport) {
+			} else if (reexport) {
 				const refInfo = moduleToInfoMap.get(reexport.module);
+				// a CommonJS `exports.x = require()` re-export keeps raw exports semantics
+				const moduleExportsAccess =
+					reexport.connection.dependency !== null &&
+					isDependencyKind(
+						reexport.connection.dependency,
+						"commonjs-export-require"
+					);
+
 				return getFinalBinding(
 					moduleGraph,
 					/** @type {ModuleInfo} */ (refInfo),
@@ -840,7 +847,7 @@ const getFinalBinding = (
 					/** @type {BuildMeta} */
 					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
-					false,
+					moduleExportsAccess,
 					alreadyVisited
 				);
 			}
@@ -858,7 +865,7 @@ const getFinalBinding = (
 				}
 				// an inlined export never reaches the exports object, so render the
 				// literal instead of reading the namespace
-				if (usedName instanceof InlinedUsedName) {
+				if (isInlinedUsedName(usedName)) {
 					return {
 						info,
 						// Literal only; suffix is appended once via `ids` (see directExport branch).
@@ -895,7 +902,7 @@ const getFinalBinding = (
 					exportName
 				};
 			}
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				return {
 					info,
 					// Literal only; suffix is appended once via `ids` (see directExport branch).
@@ -1130,6 +1137,22 @@ class ConcatenatedModule extends Module {
 		return [...this._modules];
 	}
 
+	/**
+	 * Returns the module this one was built around: itself, or the root of a scope-hoisted concatenation.
+	 * @returns {Module} the root module
+	 */
+	getRootModule() {
+		return this.rootModule;
+	}
+
+	/**
+	 * Returns the modules this one was built from: itself, or every module merged by scope hoisting.
+	 * @returns {Iterable<Module>} the source modules (do not mutate)
+	 */
+	getSourceModules() {
+		return this._modules;
+	}
+
 	/**
 	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
@@ -1368,8 +1391,13 @@ class ConcatenatedModule extends Module {
 					connections.push(c);
 				}
 			}
+			/** @type {Map<Dependency, number>} */
+			const dependencyIndices = new Map();
+			for (let i = 0; i < module.dependencies.length; i++) {
+				dependencyIndices.set(module.dependencies[i], i);
+			}
 			/**
-			 * @type {{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number | undefined, defer?: boolean }[]}
+			 * @type {{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number | undefined, dependencyIndex: number, defer?: boolean }[]}
 			 */
 			const references = connections
 				.filter((connection) => {
@@ -1396,8 +1424,9 @@ class ConcatenatedModule extends Module {
 				})
 				.map((connection) => {
 					const dep =
-						/** @type {HarmonyImportDependency} */
+						/** @type {ESMImportDependency} */
 						(connection.dependency);
+					const dependencyIndex = dependencyIndices.get(dep);
 					return {
 						connection,
 						// A require() edge carries no sourceOrder, and Infinity sorts it
@@ -1406,6 +1435,8 @@ class ConcatenatedModule extends Module {
 						sourceOrder:
 							typeof dep.sourceOrder === "number" ? dep.sourceOrder : Infinity,
 						rangeStart: dep.range && dep.range[0],
+						dependencyIndex:
+							dependencyIndex === undefined ? Infinity : dependencyIndex,
 						defer: ImportPhaseUtils.isDefer(dep.phase)
 					};
 				});
@@ -1424,8 +1455,11 @@ class ConcatenatedModule extends Module {
 			 * If there is no reexport, we have the same source.
 			 * If there is reexport, but module has side effects, this will lead to reexport module only.
 			 * If there is side-effects-free reexport, we can get simple deterministic result with range start comparison.
+			 * Re-exports of one statement share sourceOrder and have no range, so the dependency index breaks the tie.
 			 */
-			references.sort(concatComparators(bySourceOrder, byRangeStart));
+			references.sort(
+				concatComparators(bySourceOrder, byRangeStart, byDependencyIndex)
+			);
 			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 			const referencesMap = new Map();
 			/** @type {Module[] | undefined} */
@@ -1439,12 +1473,11 @@ class ConcatenatedModule extends Module {
 				const module = connection.module;
 				if (targets === undefined) targets = [module];
 				else if (!targets.includes(module)) targets.push(module);
+				const dependency = connection.dependency;
 				if (
-					[
-						CommonJsRequireDependency,
-						CommonJsFullRequireDependency,
-						CommonJsExportRequireDependency
-					].some((Dep) => connection.dependency instanceof Dep)
+					dependency !== null &&
+					(isDependencyKind(dependency, "commonjs-require") ||
+						isDependencyKind(dependency, "commonjs-export-require"))
 				) {
 					wrappedModules.add(module);
 				}
@@ -1708,7 +1741,7 @@ class ConcatenatedModule extends Module {
 	//  |     (concatenated [+wrapped] | external | reference)
 	//  v
 	//  [1] ANALYSE — inner codeGeneration() per module, into a ConcatenationScope
-	//  |     plain    -> ReplaceSource + ast + scope analysis
+	//  |     plain    -> ReplaceSource + scope analysis
 	//  |     wrapped  -> ReplaceSource only, body kept verbatim
 	//  |     external -> nothing yet, rendered as a require() below
 	//  [2] RESERVE — free globals of the analysed bodies enter allUsedNames, so
@@ -1718,7 +1751,7 @@ class ConcatenatedModule extends Module {
 	//  |     the generated names allocated: wrapper accessor, namespace object,
 	//  |     interop helpers, external import variable
 	//  [4] LINK — __WEBPACK_MODULE_REFERENCE__ tokens replaced by their final
-	//  |     binding; through the ast for analysed bodies, textually for wrapped
+	//  |     binding; through the scopes for analysed bodies, textually for wrapped
 	//  [5] COLLECT EXPORTS — root exports split into used / unused / inlined
 	//  v
 	//  ---- from here on everything is appended to the result ConcatSource ----
@@ -1797,8 +1830,8 @@ class ConcatenatedModule extends Module {
 		/** @type {Set<ConcatenatedModuleInfo | ExternalModuleInfo>} */
 		const neededEscapeNamespaceObjects = new Set();
 
-		// #region [1] ANALYSE: run each inner module's own codeGeneration; a
-		// non-wrapped body is parsed and scope-analysed so [3] can rename its locals
+		// #region [1] ANALYSE: run each inner module's own codeGeneration and
+		// scope-analyse the body; a non-wrapped one keeps its scopes for [3]
 		for (const info of moduleToInfoMap.values()) {
 			this._analyseModule(
 				moduleToInfoMap,
@@ -1862,7 +1895,7 @@ class ConcatenatedModule extends Module {
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (exportInfo.provided === false) continue;
 				const usedName = exportInfo.getUsedName(undefined, runtime);
-				if (!usedName || usedName instanceof InlinedUsedName) continue;
+				if (!usedName || isInlinedUsedName(usedName)) continue;
 				if (usedName[usedName.length - 1] !== exportInfo.name) {
 					mangled = true;
 					break;
@@ -1895,8 +1928,18 @@ class ConcatenatedModule extends Module {
 					)) {
 						allUsedNames.add(name);
 					}
-					// A wrapped body has no scope analysis, so its references are found
-					// textually. They still have to be resolved here: binding one is what
+					// only its free globals reach freeNames; the reference tokens among
+					// them are resolved textually below and patched the same way in [4]
+					for (const reference of /** @type {Reference[]} */ (
+						info.unresolvedReferences
+					)) {
+						const name = reference.identifier.name;
+						if (!ConcatenationScope.isModuleReference(name)) {
+							freeNames.add(name);
+						}
+					}
+					// A wrapped body's references are found textually, as [4] patches
+					// them. They still have to be resolved here: binding one is what
 					// flags the interop objects it needs, and [3] allocates their names.
 					/** @type {Set<string>} */
 					const visitedReferences = new Set();
@@ -2132,26 +2175,14 @@ class ConcatenatedModule extends Module {
 								for (const identifier of variable.identifiers) {
 									allIdentifiers.add(identifier);
 								}
+								const shorthandStarts =
+									/** @type {NonNullable<ConcatenatedModuleInfo["shorthandIdentifierStarts"]>} */
+									(info.shorthandIdentifierStarts);
 								for (const identifier of allIdentifiers) {
 									const r = /** @type {Range} */ (identifier.range);
-									const path = getPathInAst(
-										/** @type {NonNullable<ConcatenatedModuleInfo["ast"]>} */
-										(info.ast),
-										identifier
-									);
-									if (path && path.length > 1) {
-										const maybeProperty =
-											path[1].type === "AssignmentPattern" &&
-											path[1].left === path[0]
-												? path[2]
-												: path[1];
-										if (
-											maybeProperty.type === "Property" &&
-											maybeProperty.shorthand
-										) {
-											source.insert(r[1], `: ${newName}`);
-											continue;
-										}
+									if (shorthandStarts.has(r[0])) {
+										source.insert(r[1], `: ${newName}`);
+										continue;
 									}
 									source.replace(r[0], r[1] - 1, newName);
 								}
@@ -2358,8 +2389,8 @@ class ConcatenatedModule extends Module {
 					}
 				}
 			} else {
-				// Wrapped bodies are not re-parsed: find their reference tokens
-				// textually. [2] scanned the same source, so this reuses its result.
+				// A wrapped body's reference tokens are found textually rather than
+				// in its AST. [2] scanned the same source, so this reuses its result.
 				/** @type {Map<string, string>} */
 				const finalNames = new Map();
 				const source = /** @type {ReplaceSource} */ (info.source);
@@ -2442,7 +2473,7 @@ class ConcatenatedModule extends Module {
 				unusedExports.add(name);
 				continue;
 			}
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				inlinedExports.add(name);
 				continue;
 			}
@@ -2565,7 +2596,7 @@ class ConcatenatedModule extends Module {
 				if (exportInfo.provided === false) continue;
 				const usedName = exportInfo.getUsedName(undefined, runtime);
 				if (!usedName) continue;
-				if (usedName instanceof InlinedUsedName) {
+				if (isInlinedUsedName(usedName)) {
 					nsObj.push(
 						`\n  ${propertyName(
 							exportInfo.name
@@ -2646,7 +2677,7 @@ ${defineGetters}`
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (exportInfo.provided === false) continue;
 				const usedName = exportInfo.getUsedName(undefined, runtime);
-				if (usedName && !(usedName instanceof InlinedUsedName)) {
+				if (usedName && !isInlinedUsedName(usedName)) {
 					const finalName = getFinalName(
 						moduleGraph,
 						info,
@@ -2716,14 +2747,26 @@ ${defineGetters}`
 		for (const info of wrappedInfos) {
 			if (info.type === "concatenated") {
 				runtimeRequirements.add(RuntimeGlobals.concatenationWrap);
+				const bodyRuntimeRequirements =
+					/** @type {ReadOnlyRuntimeRequirements} */
+					(info.runtimeRequirements);
 				result.add(
 					`\n// MODULE: ${info.module.readableIdentifier(
 						requestShortener
 					)}\nvar ${info.namespaceFnName} = /*#__PURE__*/${
 						RuntimeGlobals.concatenationWrap
-					}(function(${info.module.moduleArgument}, ${
-						info.module.exportsArgument
-					}) {\n`
+					}(${runtimeTemplate.moduleFactoryFnHeader({
+						module: info.module,
+						// the trailing `module.exports` assignment below reads it
+						needModule:
+							Boolean(info.namespaceExportSymbol) ||
+							bodyRuntimeRequirements.has(RuntimeGlobals.module),
+						needExports: bodyRuntimeRequirements.has(RuntimeGlobals.exports),
+						needRequire: false,
+						needThisAsExports: bodyRuntimeRequirements.has(
+							RuntimeGlobals.thisAsExports
+						)
+					})}\n`
 				);
 				result.add(/** @type {ReplaceSource} */ (info.source));
 				// A generated body binds its value to a local rather than writing
@@ -2810,7 +2853,7 @@ ${defineGetters}`
 				result.add(
 					`\n// DEFERRED EXTERNAL MODULE: ${info.module.readableIdentifier(
 						requestShortener
-					)}\nvar ${info.deferredName} = ${loader};`
+					)}\nvar ${info.deferredName} = ${runtimeTemplate.sideEffectsAnnotation()}${loader};`
 				);
 				if (info.deferredNamespaceObjectUsed) {
 					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
@@ -2924,7 +2967,10 @@ ${defineGetters}`
 						// External module bindings may be wrapped in
 						// runtime-condition `if` blocks but referenced outside,
 						// so they must remain function-scoped (`var`).
-						const required = `__webpack_require__(${moduleId})`;
+						const required = `${runtimeTemplate.moduleSideEffectsAnnotation(
+							info.module,
+							moduleGraph
+						)}__webpack_require__(${moduleId})`;
 
 						// The wrapping happens per reference, so only the helper has
 						// to be declared here.
@@ -3058,123 +3104,92 @@ ${defineGetters}`
 		codeGenerationResults,
 		usedNames
 	) {
-		if (info.type === "concatenated") {
-			const m = info.module;
-			if (info.wrapped) {
-				// the wrapper isolates the body's top-level declarations, so only a
-				// concatenation scope is needed, rewriting in-scope `require()` targets.
-				// Stage 2 claims its identifiers textually, in place of that analysis.
-				const concatenationScope = new ConcatenationScope(
-					modulesMap,
-					info,
-					usedNames
-				);
-				info.concatenationScope = concatenationScope;
-				const codeGenResult = m.codeGeneration({
-					dependencyTemplates,
-					runtimeTemplate,
-					moduleGraph,
-					chunkGraph,
-					runtime,
-					runtimes,
-					concatenationScope,
-					codeGenerationResults,
-					sourceTypes: JAVASCRIPT_TYPES
-				});
-				const source =
-					/** @type {Source} */
-					(codeGenResult.sources.get(JAVASCRIPT_TYPE));
-				const data = codeGenResult.data;
-				info.runtimeRequirements =
-					/** @type {ReadOnlyRuntimeRequirements} */
-					(codeGenResult.runtimeRequirements);
-				info.internalSource = source;
-				info.source = new ReplaceSource(source);
-				info.chunkInitFragments = data && data.get("chunkInitFragments");
-			} else {
-				try {
-					// Create a concatenation scope to track and capture information
-					const concatenationScope = new ConcatenationScope(
-						modulesMap,
-						info,
-						usedNames
-					);
+		if (info.type !== "concatenated") return;
+		const m = info.module;
+		try {
+			// Create a concatenation scope to track and capture information
+			const concatenationScope = new ConcatenationScope(
+				modulesMap,
+				info,
+				usedNames
+			);
 
-					// Not cached: Compilation memoizes the outer codeGeneration per
-					// (module, runtime), so inner generation never recomputes usefully.
-					const codeGenResult = m.codeGeneration({
-						dependencyTemplates,
-						runtimeTemplate,
-						moduleGraph,
-						chunkGraph,
-						runtime,
-						runtimes,
-						concatenationScope,
-						codeGenerationResults,
-						sourceTypes: JAVASCRIPT_TYPES
-					});
-					const source =
-						/** @type {Source} */
-						(codeGenResult.sources.get(JAVASCRIPT_TYPE));
-					const data = codeGenResult.data;
-					const chunkInitFragments = data && data.get("chunkInitFragments");
-					const code = source.source().toString();
-
-					/** @type {Program} */
-					let ast;
-
-					try {
-						const { experiments } = this.compilation.options;
-
-						({ ast } = JavascriptParser._parse(
-							code,
-							{
-								sourceType: "module",
-								ranges: true,
-								// generated code contains phase imports when the experiments are on
-								importPhases: Boolean(
-									experiments.deferImport || experiments.sourceImport
-								)
-							},
-							JavascriptParser._getModuleParseFunction(this.compilation, m)
-						));
-					} catch (_err) {
-						const err =
-							/** @type {Error & { loc?: { line: number, column: number } }} */
-							(_err);
-						if (
-							err.loc &&
-							typeof err.loc === "object" &&
-							typeof err.loc.line === "number"
-						) {
-							const lineNumber = err.loc.line;
-							const lines = code.split("\n");
-							err.message += `\n| ${lines
-								.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
-								.join("\n| ")}`;
-						}
-						throw err;
-					}
-					const analysis = analyzeScope(ast);
-					const resultSource = new ReplaceSource(source);
-					info.runtimeRequirements =
-						/** @type {ReadOnlyRuntimeRequirements} */
-						(codeGenResult.runtimeRequirements);
-					info.ast = ast;
-					info.internalSource = source;
-					info.source = resultSource;
-					info.chunkInitFragments = chunkInitFragments;
-					info.globalScope = analysis.globalScope;
-					info.moduleScope = analysis.moduleScope;
-					info.unresolvedReferences = analysis.unresolvedReferences;
-					info.concatenationScope = concatenationScope;
-				} catch (err) {
-					/** @type {Error} */
-					(err).message +=
-						`\nwhile analyzing module ${m.identifier()} for concatenation`;
-					throw err;
+			// Not cached: Compilation memoizes the outer codeGeneration per
+			// (module, runtime), so inner generation never recomputes usefully.
+			const codeGenResult = m.codeGeneration({
+				dependencyTemplates,
+				runtimeTemplate,
+				moduleGraph,
+				chunkGraph,
+				runtime,
+				runtimes,
+				concatenationScope,
+				codeGenerationResults,
+				sourceTypes: JAVASCRIPT_TYPES
+			});
+			const source =
+				/** @type {Source} */
+				(codeGenResult.sources.get(JAVASCRIPT_TYPE));
+			const data = codeGenResult.data;
+			const chunkInitFragments = data && data.get("chunkInitFragments");
+			const code = source.source().toString();
+
+			/** @type {Program} */
+			let ast;
+
+			try {
+				const { experiments } = this.compilation.options;
+
+				({ ast } = JavascriptParser._parse(
+					code,
+					{
+						// a wrapped CommonJS body may `return` at its top level
+						sourceType: info.wrapped ? "auto" : "module",
+						ranges: true,
+						// generated code contains phase imports when the experiments are on
+						importPhases: Boolean(
+							experiments.deferImport || experiments.sourceImport
+						)
+					},
+					JavascriptParser._getModuleParseFunction(this.compilation, m)
+				));
+			} catch (_err) {
+				const err =
+					/** @type {Error & { loc?: { line: number, column: number } }} */
+					(_err);
+				if (
+					err.loc &&
+					typeof err.loc === "object" &&
+					typeof err.loc.line === "number"
+				) {
+					const lineNumber = err.loc.line;
+					const lines = code.split("\n");
+					err.message += `\n| ${lines
+						.slice(Math.max(0, lineNumber - 3), lineNumber + 2)
+						.join("\n| ")}`;
 				}
+				throw err;
 			}
+			const analysis = analyzeScope(ast);
+			info.runtimeRequirements =
+				/** @type {ReadOnlyRuntimeRequirements} */
+				(codeGenResult.runtimeRequirements);
+			info.internalSource = source;
+			info.source = new ReplaceSource(source);
+			info.chunkInitFragments = chunkInitFragments;
+			info.unresolvedReferences = analysis.unresolvedReferences;
+			info.concatenationScope = concatenationScope;
+			// the wrapper isolates the body's declarations, so [3] renames nothing in
+			// it and its scopes are not kept; [2] claims its identifiers textually
+			if (info.wrapped) return;
+			info.shorthandIdentifierStarts = analysis.shorthandIdentifierStarts;
+			info.globalScope = analysis.globalScope;
+			info.moduleScope = analysis.moduleScope;
+		} catch (err) {
+			/** @type {Error} */
+			(err).message +=
+				`\nwhile analyzing module ${m.identifier()} for concatenation`;
+			throw err;
 		}
 	}
 
@@ -3204,7 +3219,7 @@ ${defineGetters}`
 							module: info.module,
 							index,
 							namespaceFnName: undefined,
-							ast: undefined,
+							shorthandIdentifierStarts: undefined,
 							chunkInitFragments: undefined,
 							internalSource: undefined,
 							runtimeRequirements: undefined,
@@ -3321,13 +3336,10 @@ ${defineGetters}`
 	 * @returns {ConcatenatedModule} ConcatenatedModule
 	 */
 	static deserialize(context) {
-		const obj = new ConcatenatedModule({
-			identifier: /** @type {EXPECTED_ANY} */ (undefined),
-			rootModule: /** @type {EXPECTED_ANY} */ (undefined),
-			modules: /** @type {EXPECTED_ANY} */ (undefined),
-			runtime: undefined,
-			compilation: /** @type {EXPECTED_ANY} */ (undefined)
-		});
+		const obj = new ConcatenatedModule(
+			// every field is restored by `deserialize` and `updateCacheModule`
+			/** @type {ConstructorParameters<typeof ConcatenatedModule>[0]} */ ({})
+		);
 		obj.deserialize(context);
 		return obj;
 	}
@@ -3345,6 +3357,9 @@ ConcatenatedModule.getCompilationHooks = createHooksRegistry(
 
 makeSerializable(ConcatenatedModule, "webpack/lib/optimize/ConcatenatedModule");
 
+/** @type {Set<keyof ModuleKinds>} */
+ConcatenatedModule.KINDS = new Set([...Module.KINDS, "concatenated"]);
+
 /** @type {WeakMap<Compilation, WeakMap<Module, ConcatenatedModule>>} */
 const absorbedBy = new WeakMap();
 
@@ -3361,7 +3376,7 @@ ConcatenatedModule.getChunkGraphModule = (compilation, module) => {
 	if (map === undefined) {
 		map = new WeakMap();
 		for (const candidate of compilation.modules) {
-			if (candidate instanceof ConcatenatedModule) {
+			if (candidate.is("concatenated")) {
 				for (const inner of candidate._modules) {
 					map.set(inner, candidate);
 				}