webpack 5.110.2 → 5.111.0

package/lib/Compiler.js

@@ -5,8 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
-
 const {
 	AsyncParallelHook,
 	AsyncSeriesHook,
@@ -26,7 +24,8 @@ const ResolverFactory = require("./ResolverFactory");
 const Stats = require("./Stats");
 const WebpackError = require("./errors/WebpackError");
 const { Logger } = require("./logging/Logger");
-const { dirname, join, mkdirp } = require("./util/fs");
+const asyncLib = require("./util/async");
+const { PERMISSIONS_MASK, dirname, join, mkdirp } = require("./util/fs");
 const {
 	WINDOWS_ABS_PATH_REGEXP,
 	makePathsRelative
@@ -45,6 +44,7 @@ const getConcurrentCompilationError = memoize(() =>
 );
 
 /** @import { Source } from "webpack-sources" */
+/** @import { AssetInfo, AssetSymlink } from "./Compilation" */
 /**
  * @import {
  * 	EntryNormalized as Entry,
@@ -497,29 +497,33 @@ class Compiler {
 	// e.g. move compilation specific info from Modules into ModuleGraph
 	_cleanupLastCompilation() {
 		if (this._lastCompilation !== undefined) {
-			for (const childCompilation of this._lastCompilation.children) {
-				for (const module of childCompilation.modules) {
-					ChunkGraph.clearChunkGraphForModule(module);
-					ModuleGraph.clearModuleGraphForModule(module);
-					module.cleanupForCache();
-				}
-				for (const chunk of childCompilation.chunks) {
-					ChunkGraph.clearChunkGraphForChunk(chunk);
-				}
-			}
-
-			for (const module of this._lastCompilation.modules) {
-				ChunkGraph.clearChunkGraphForModule(module);
-				ModuleGraph.clearModuleGraphForModule(module);
-				module.cleanupForCache();
-			}
-			for (const chunk of this._lastCompilation.chunks) {
-				ChunkGraph.clearChunkGraphForChunk(chunk);
-			}
+			this._cleanupCompilationForCache(this._lastCompilation);
 			this._lastCompilation = undefined;
 		}
 	}
 
+	/**
+	 * Drops the graph references a finished compilation left on its modules and
+	 * chunks. Recurses, because child compilations nest: a module only reached
+	 * below the first level keeps its parser, generator and memoized
+	 * `ModuleGraph`, which pins the whole stale compilation.
+	 * @param {Compilation} compilation compilation to clean up
+	 * @returns {void}
+	 */
+	_cleanupCompilationForCache(compilation) {
+		for (const childCompilation of compilation.children) {
+			this._cleanupCompilationForCache(childCompilation);
+		}
+		for (const module of compilation.modules) {
+			ChunkGraph.clearChunkGraphForModule(module);
+			ModuleGraph.clearModuleGraphForModule(module);
+			module.cleanupForCache();
+		}
+		for (const chunk of compilation.chunks) {
+			ChunkGraph.clearChunkGraphForChunk(chunk);
+		}
+	}
+
 	// TODO webpack 6: solve this in a better way
 	_cleanupLastNormalModuleFactory() {
 		if (this._lastNormalModuleFactory !== undefined) {
@@ -671,6 +675,7 @@ class Compiler {
 							if (err) return finalCallback(err);
 							this.cache.storeBuildDependencies(
 								compilation.buildDependencies,
+								compilation.optionalBuildDependencies,
 								(err) => {
 									if (err) return finalCallback(err);
 									return finalCallback(null, stats);
@@ -796,7 +801,7 @@ class Compiler {
 			const caseInsensitiveMap = new Map();
 			/** @type {Set<string>} */
 			const allTargetPaths = new Set();
-			asyncLib.forEachLimit(
+			asyncLib.eachLimit(
 				assets,
 				15,
 				({ name: file, source, info }, callback) => {
@@ -833,6 +838,17 @@ class Compiler {
 						if (err) return callback(err);
 						allTargetPaths.add(targetPath);
 
+						// a link is created rather than written, and none of the content
+						// caching below applies to one
+						if (info.symlink) {
+							return this._emitSymlink(
+								compilation,
+								{ file, source, outputPath, targetPath },
+								info.symlink,
+								callback
+							);
+						}
+
 						// check if the target file has already been written by this Compiler
 						const targetFileGeneration =
 							this._assetEmittingWrittenFiles.get(targetPath);
@@ -928,28 +944,37 @@ ${other}`);
 							(this.outputFileSystem).writeFile(targetPath, content, (err) => {
 								if (err) return callback(err);
 
-								// information marker that the asset has been emitted
-								compilation.emittedAssets.add(file);
+								// set on what was just written, so a file the comparison above
+								// left alone keeps what it already carries
+								this._setAssetFileAttributes(targetPath, info, (err) => {
+									if (err) return callback(err);
 
-								// cache the information that the Source has been written to that location
-								const newGeneration =
-									targetFileGeneration === undefined
-										? 1
-										: targetFileGeneration + 1;
-								/** @type {CacheEntry} */
-								(cacheEntry).writtenTo.set(targetPath, newGeneration);
-								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								this.hooks.assetEmitted.callAsync(
-									file,
-									{
-										content,
-										source,
-										outputPath,
-										compilation,
-										targetPath
-									},
-									callback
-								);
+									// information marker that the asset has been emitted
+									compilation.emittedAssets.add(file);
+
+									// cache the information that the Source has been written to that location
+									const newGeneration =
+										targetFileGeneration === undefined
+											? 1
+											: targetFileGeneration + 1;
+									/** @type {CacheEntry} */
+									(cacheEntry).writtenTo.set(targetPath, newGeneration);
+									this._assetEmittingWrittenFiles.set(
+										targetPath,
+										newGeneration
+									);
+									this.hooks.assetEmitted.callAsync(
+										file,
+										{
+											content,
+											source,
+											outputPath,
+											compilation,
+											targetPath
+										},
+										callback
+									);
+								});
 							});
 						};
 
@@ -998,6 +1023,30 @@ ${other}`);
 							});
 						};
 
+						/**
+						 * Keeps the file already on disk, giving it the permissions and times
+						 * the asset carries — the build which wrote it may not have set them.
+						 * Only the modification time is compared, as reading a file moves its
+						 * access time.
+						 * @param {IStats} stats stats of the file on disk
+						 * @returns {void}
+						 */
+						const keepExistingFile = (stats) => {
+							const differs =
+								(info.mode !== undefined &&
+									(stats.mode & PERMISSIONS_MASK) !== info.mode) ||
+								(info.timestamps !== undefined &&
+									// compared at the precision `utimes` wrote, as a `Date` drops
+									// the sub-millisecond part a filesystem may report
+									Math.trunc(stats.mtimeMs) !==
+										Math.trunc(info.timestamps.mtime));
+							if (!differs) return alreadyWritten();
+							this._setAssetFileAttributes(targetPath, info, (err) => {
+								if (err) return callback(err);
+								alreadyWritten();
+							});
+						};
+
 						/**
 						 * Process existing file.
 						 * @param {IStats} stats stats
@@ -1007,7 +1056,7 @@ ${other}`);
 							// skip emitting if it's already there and an immutable file
 							if (immutable) {
 								updateWithReplacementSource(/** @type {number} */ (stats.size));
-								return alreadyWritten();
+								return keepExistingFile(stats);
 							}
 
 							const content = getContent();
@@ -1029,7 +1078,7 @@ ${other}`);
 									) {
 										return doWrite(content);
 									}
-									return alreadyWritten();
+									return keepExistingFile(stats);
 								});
 							}
 
@@ -1132,6 +1181,120 @@ ${other}`);
 		});
 	}
 
+	/**
+	 * Gives the file an asset was written to the permissions and the times the
+	 * asset carries. A symbolic link never carries either, as both follow it to
+	 * its target.
+	 * @private
+	 * @param {string} targetPath absolute path of the file
+	 * @param {AssetInfo} info info of the asset
+	 * @param {ErrorCallback} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_setAssetFileAttributes(targetPath, info, callback) {
+		const { mode, timestamps } = info;
+		if (mode === undefined && timestamps === undefined) return callback(null);
+		const fs = /** @type {OutputFileSystem} */ (this.outputFileSystem);
+
+		/**
+		 * @param {(Error | null)=} err error of the step before
+		 * @returns {void}
+		 */
+		const setTimestamps = (err) => {
+			if (err) return callback(err);
+			if (timestamps === undefined) return callback(null);
+			if (!fs.utimes) {
+				return callback(
+					new WebpackError(
+						`Unable to set the times of '${targetPath}': the output file system cannot set them`
+					)
+				);
+			}
+			/** @type {NonNullable<OutputFileSystem["utimes"]>} */
+			(fs.utimes)(
+				targetPath,
+				new Date(timestamps.atime),
+				new Date(timestamps.mtime),
+				(err) => callback(err || null)
+			);
+		};
+
+		if (mode === undefined) return setTimestamps();
+		if (!fs.chmod) {
+			return callback(
+				new WebpackError(
+					`Unable to set the permissions of '${targetPath}': the output file system cannot set them`
+				)
+			);
+		}
+		/** @type {NonNullable<OutputFileSystem["chmod"]>} */
+		(fs.chmod)(targetPath, mode, setTimestamps);
+	}
+
+	/**
+	 * Creates an asset which is a symbolic link, replacing whatever else is at
+	 * its path. An existing link already pointing there is left alone, so a watch
+	 * rebuild does not touch it.
+	 * @private
+	 * @param {Compilation} compilation the compilation
+	 * @param {object} asset the asset which is a link
+	 * @param {string} asset.file the filename of the asset
+	 * @param {Source} asset.source content of the asset, which is what the link points at
+	 * @param {string} asset.outputPath absolute path the assets are emitted into
+	 * @param {string} asset.targetPath absolute path the link is created at
+	 * @param {AssetSymlink} symlink what the link points at
+	 * @param {ErrorCallback} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_emitSymlink(compilation, asset, symlink, callback) {
+		const { file, source, outputPath, targetPath } = asset;
+		const fs = /** @type {OutputFileSystem} */ (this.outputFileSystem);
+		if (!fs.symlink) {
+			return callback(
+				new WebpackError(
+					`Unable to emit '${file}' as a symbolic link: the output file system cannot create one`
+				)
+			);
+		}
+		const { target, isDirectory } = symlink;
+
+		const created = () => {
+			compilation.emittedAssets.add(file);
+			this.hooks.assetEmitted.callAsync(
+				file,
+				{
+					content: Buffer.from(target, "utf8"),
+					source,
+					outputPath,
+					compilation,
+					targetPath
+				},
+				callback
+			);
+		};
+
+		const create = () => {
+			/** @type {NonNullable<OutputFileSystem["symlink"]>} */
+			(fs.symlink)(target, targetPath, isDirectory ? "dir" : "file", (err) => {
+				if (err) return callback(err);
+				created();
+			});
+		};
+
+		const replace = () => {
+			if (!fs.unlink) return create();
+			/** @type {NonNullable<OutputFileSystem["unlink"]>} */
+			(fs.unlink)(targetPath, () => create());
+		};
+
+		if (!fs.readlink) return replace();
+		/** @type {NonNullable<OutputFileSystem["readlink"]>} */
+		(fs.readlink)(targetPath, (err, existingTarget) => {
+			if (!err && existingTarget === target) return callback(null);
+			replace();
+		});
+	}
+
 	/**
 	 * Processes the provided error callback.
 	 * @param {ErrorCallback} callback signals when the call finishes

package/lib/ConcatenationScope.js

@@ -19,9 +19,10 @@ const {
  * 	ExportName as Ids
  * } from "./optimize/ConcatenatedModule"
  */
-/** @import { Range } from "./javascript/JavascriptParser" */
 
-/** @typedef {{ start: number, end: number, name: string }} ModuleReferenceMatch */
+/** @typedef {{ start: number, end: number, name: string, leaked: boolean }} ModuleReferenceMatch */
+
+const MODULE_REFERENCE_TOKEN = "__WEBPACK_MODULE_REFERENCE__";
 
 const MODULE_REFERENCE_REGEXP =
 	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(_mangleableNs)?(_moduleExportsAccess)?(?:_asiSafe(\d))?__$/;
@@ -33,6 +34,8 @@ const MODULE_REFERENCE_SCAN_REGEXP = new RegExp(
 	"g"
 );
 
+const IDENTIFIER_CHARACTER_REGEXP = /[\w$]/;
+
 /** @type {WeakMap<Source, ModuleReferenceMatch[]>} */
 const moduleReferencesCache = new WeakMap();
 
@@ -76,10 +79,6 @@ class ConcatenationScope {
 		this.usedNames = usedNames;
 		/** @type {Map<Module, ModuleInfo>} */
 		this._modulesMap = modulesMap;
-		// written and read by dependency templates within a single code
-		// generation pass, never across passes
-		/** @type {Range[] | undefined} */
-		this._replacedRequireRanges = undefined;
 	}
 
 	/**
@@ -121,33 +120,6 @@ class ConcatenationScope {
 		return this._currentModule.wrapped;
 	}
 
-	/**
-	 * Records a `require(...)` call that was replaced as a whole by a
-	 * concatenation reference, so nothing else rewrites a range inside it.
-	 * @param {Range} range source range of the replaced call
-	 */
-	registerReplacedRequire(range) {
-		if (this._replacedRequireRanges === undefined) {
-			this._replacedRequireRanges = [];
-		}
-		this._replacedRequireRanges.push(range);
-	}
-
-	/**
-	 * Checks whether an offset sits inside an already-replaced `require(...)` call.
-	 * Containment, not exact match: `new require(...)` is replaced from `new`.
-	 * @param {number} start start offset to test
-	 * @returns {boolean} true, when the offset was replaced already
-	 */
-	isInsideReplacedRequire(start) {
-		const ranges = this._replacedRequireRanges;
-		if (ranges === undefined) return false;
-		for (const [rangeStart, rangeEnd] of ranges) {
-			if (start >= rangeStart && start < rangeEnd) return true;
-		}
-		return false;
-	}
-
 	/**
 	 * Records the symbol that should be used when the current module exports a
 	 * named binding.
@@ -263,7 +235,22 @@ class ConcatenationScope {
 	}
 
 	/**
-	 * Finds all encoded module references in a generated source.
+	 * Checks whether an identifier buries a reference token without being one,
+	 * which nothing can resolve: it would reach the output as an undeclared global.
+	 * @param {string} name the identifier
+	 * @returns {boolean} true, when a reference token is buried in the identifier
+	 */
+	static isLeakedModuleReference(name) {
+		return (
+			name.includes(MODULE_REFERENCE_TOKEN) &&
+			!MODULE_REFERENCE_REGEXP.test(name)
+		);
+	}
+
+	/**
+	 * Finds all encoded module references in a generated source. A match that
+	 * continues an identifier is reported as `leaked`: it is a token a wider
+	 * replacement swallowed, so substituting it would rewrite the middle of a name.
 	 * @param {Source} source generated source
 	 * @returns {ModuleReferenceMatch[]} reference token positions (end is exclusive, excludes the appended "._")
 	 */
@@ -279,7 +266,10 @@ class ConcatenationScope {
 			result.push({
 				start: match.index,
 				end: match.index + match[0].length,
-				name: match[0]
+				name: match[0],
+				leaked:
+					match.index > 0 &&
+					IDENTIFIER_CHARACTER_REGEXP.test(code[match.index - 1])
 			});
 			match = MODULE_REFERENCE_SCAN_REGEXP.exec(code);
 		}

package/lib/ContextModule.js

@@ -213,6 +213,7 @@ class ContextModule extends Module {
 	 * @returns {void}
 	 */
 	updateCacheModule(module) {
+		super.updateCacheModule(module);
 		const m = /** @type {ContextModule} */ (module);
 		this.resolveDependencies = m.resolveDependencies;
 		this.options = m.options;
@@ -878,7 +879,9 @@ class ContextModule extends Module {
 			}
 			const type =
 				typeof fakeMap === "number" ? fakeMap : fakeMapDataExpression;
-			return `${asyncDeps} ? ${asyncDeps}.length ? ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${asyncDeps}).then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, id, ${type} ^ 1, true)) : ${RuntimeGlobals.makeDeferredNamespaceObject}(id, ${type} ^ 1 | 16) : ${source}`;
+			// The bound third argument absorbs the promise's resolved value, which
+			// would otherwise land in the export-names parameter.
+			return `${asyncDeps} ? ${asyncDeps}.length ? ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(${asyncDeps}).then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, id, ${type} ^ 1, undefined)) : ${RuntimeGlobals.makeDeferredNamespaceObject}(id, ${type} ^ 1 | 16) : ${source}`;
 		}
 		return source;
 	}
@@ -1212,60 +1215,11 @@ module.exports = webpackAsyncContext;`;
 		}
 		const shortMode = hasNoChunk && hasNoModuleDeferred && !hasFakeMap;
 		// Sorted before anything is keyed by request, so two items sharing one leave the
-		// same last writer in the map and in the loaders beside it.
+		// same last writer in the map.
 		const sortedItems = items.sort((a, b) => {
 			if (a.userRequest === b.userRequest) return 0;
 			return a.userRequest < b.userRequest ? -1 : 1;
 		});
-		let needEnsureChunk = !hasNoChunk;
-		/** @type {Map<string, string[]> | undefined} */
-		let loaders;
-		// Only module output can name a chunk in an `import()`, so nothing else pays for
-		// building the loaders just to throw them away.
-		if (!hasNoChunk && runtimeTemplate.isModule()) {
-			/** @type {Map<string, string[]>} */
-			const perRequest = new Map();
-			let hasAnalyzable = false;
-			let hasFallback = false;
-			/**
-			 * @param {Chunk} chunk one chunk a request needs
-			 * @returns {string} a thunk loading it, by literal name where the chunk has one
-			 */
-			const loaderFor = (chunk) => {
-				// `.ei` always imports, where `.e` skips a chunk already loaded — the same
-				// filter `blockPromise` applies before reaching for it.
-				const analyzable =
-					chunk.hasRuntime() || chunk.id === null
-						? null
-						: runtimeTemplate.analyzableChunkImport(
-								chunk,
-								"",
-								runtimeRequirements,
-								this,
-								chunkGraph
-							);
-				if (analyzable !== null) {
-					hasAnalyzable = true;
-					return runtimeTemplate.returningFunction(analyzable);
-				}
-				hasFallback = true;
-				return runtimeTemplate.returningFunction(
-					`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)})`
-				);
-			};
-			for (const item of sortedItems) {
-				perRequest.set(
-					item.userRequest,
-					/** @type {Chunk[]} */ (item.chunks).map(loaderFor)
-				);
-			}
-			// Nothing gained when no chunk can be spelled out, and the plain id map is
-			// smaller, so the loaders are only written when at least one names its chunk.
-			if (hasAnalyzable) {
-				loaders = perRequest;
-				needEnsureChunk = hasFallback;
-			}
-		}
 		/** @type {Record<string, ModuleId | (ModuleId | FakeMapType | ChunkId[] | (ModuleId[] | undefined))[]>} */
 		const map = Object.create(null);
 		for (const item of sortedItems) {
@@ -1299,16 +1253,16 @@ module.exports = webpackAsyncContext;`;
 		const asyncDepsPosition = hasNoChunk ? chunksPosition : chunksPosition + 1;
 		const requestPrefix = hasNoChunk
 			? "Promise.resolve()"
-			: loaders !== undefined
-				? hasMultipleOrNoChunks
-					? `Promise.all(ids[${chunksPosition}].map(${runtimeTemplate.returningFunction("load()", "load")}))`
-					: `ids[${chunksPosition}][0]()`
-				: hasMultipleOrNoChunks
-					? `Promise.all(ids[${chunksPosition}].map(${RuntimeGlobals.ensureChunk}))`
-					: `${RuntimeGlobals.ensureChunk}(ids[${chunksPosition}][0])`;
-		// Only the id map reads it; nothing loads a chunk when there is none to load, and
-		// a map of loaders spells out every one it could reach for.
-		if (needEnsureChunk) {
+			: hasMultipleOrNoChunks
+				? // Wrapped because `map` hands its callback an index too, which the loader
+					// would otherwise read as a fetch priority.
+					`Promise.all(ids[${chunksPosition}].map(${runtimeTemplate.returningFunction(
+						`${RuntimeGlobals.ensureChunk}(id)`,
+						"id"
+					)}))`
+				: `${RuntimeGlobals.ensureChunk}(ids[${chunksPosition}][0])`;
+		// Nothing loads a chunk when there is none to load.
+		if (!hasNoChunk) {
 			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
 		}
 		const returnModuleObject = this.getReturnModuleObjectSource(
@@ -1352,26 +1306,7 @@ function webpackAsyncContext(req) {
 	return ${requestPrefix}.then(${runtimeTemplate.returningFunction(returnModuleObject)});
 }`;
 
-		// A loader is source, not data, so the map holding one is written out rather than
-		// serialized — one entry per line, keeping the request next to what loads it.
-		const mapSource =
-			loaders === undefined
-				? JSON.stringify(map, null, "\t")
-				: `{\n${Object.keys(map)
-						.map((request) => {
-							const slots =
-								/** @type {(ModuleId | FakeMapType | ChunkId[] | (ModuleId[] | undefined))[]} */
-								(map[request]).map((slot, index) =>
-									index === chunksPosition
-										? `[${/** @type {string[]} */ (loaders.get(request)).join(", ")}]`
-										: // An absent `asyncDeps` slot is `null` to `JSON.stringify`.
-											slot === undefined
-											? "null"
-											: JSON.stringify(slot)
-								);
-							return `\t${JSON.stringify(request)}: [${slots.join(", ")}]`;
-						})
-						.join(",\n")}\n}`;
+		const mapSource = JSON.stringify(map, null, "\t");
 
 		return `${cst} map = ${mapSource};
 ${webpackAsyncContext}
@@ -1742,6 +1677,7 @@ module.exports = webpackEmptyAsyncContext;`;
 				ImportPhaseUtils.isDefer(this.options.phase || ImportPhase.Evaluation)
 			) {
 				set.add(RuntimeGlobals.makeDeferredNamespaceObject);
+				set.add(RuntimeGlobals.hasSynthesizedDeferredNamespace);
 			}
 		}
 		return {

package/lib/ContextModuleFactory.js

@@ -5,12 +5,12 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const { AsyncSeriesWaterfallHook, SyncWaterfallHook } = require("tapable");
 const ContextModule = require("./ContextModule");
 const ModuleFactory = require("./ModuleFactory");
 const ContextElementDependency = require("./dependencies/ContextElementDependency");
 const LazySet = require("./util/LazySet");
+const asyncLib = require("./util/async");
 const { cachedSetProperty } = require("./util/cleverMerge");
 const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");