@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/Compiler.js

@@ -5,8 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
-
 const {
 	AsyncParallelHook,
 	AsyncSeriesHook,
@@ -18,15 +16,16 @@ const Cache = require("./Cache");
 const CacheFacade = require("./CacheFacade");
 const ChunkGraph = require("./ChunkGraph");
 const Compilation = require("./Compilation");
-const ContextModuleFactory = require("./ContextModuleFactory");
 const ModuleGraph = require("./ModuleGraph");
 const NormalModuleFactory = require("./NormalModuleFactory");
 const RequestShortener = require("./RequestShortener");
 const ResolverFactory = require("./ResolverFactory");
 const Stats = require("./Stats");
+const ContextModuleFactory = require("./context/ContextModuleFactory");
 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,17 +1056,16 @@ ${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();
 
 							updateWithReplacementSource(content.length);
 
-							// if it exists and content on disk matches content
-							// skip writing the same content again
-							// (to keep mtime and don't trigger watchers)
-							// for a fast negative match file size is compared first
+							// Skip rewriting content already on disk, which would move the
+							// mtime and wake watchers. Size is compared first, as a cheap
+							// negative match.
 							if (content.length === stats.size) {
 								compilation.comparedForEmitAssets.add(file);
 								return /** @type {OutputFileSystem} */ (
@@ -1029,7 +1077,7 @@ ${other}`);
 									) {
 										return doWrite(content);
 									}
-									return alreadyWritten();
+									return keepExistingFile(stats);
 								});
 							}
 
@@ -1132,6 +1180,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/ConstPlugin.js

@@ -219,17 +219,8 @@ class ConstPlugin {
 								} else {
 									parser.walkExpression(expression.test);
 								}
-								// Expressions do not hoist.
-								// It is safe to remove the dead branch.
-								//
-								// Given the following code:
-								//
-								//   false ? someExpression() : otherExpression();
-								//
-								// the generated code is:
-								//
-								//   false ? 0 : otherExpression();
-								//
+								// Expressions do not hoist, so the dead branch is safe to remove:
+								// `false ? someExpression() : other()` becomes `false ? 0 : other()`.
 								const branchToRemove = bool
 									? expression.alternate
 									: expression.consequent;
@@ -254,49 +245,9 @@ class ConstPlugin {
 								const param = parser.evaluateExpression(expression.left);
 								const bool = param.asBool();
 								if (typeof bool === "boolean") {
-									// Expressions do not hoist.
-									// It is safe to remove the dead branch.
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   falsyExpression() && false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() && someExpression();
-									//
-									// the generated code is:
-									//
-									//   true && someExpression();
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   truthyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   truthyExpression() || false;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   falsyExpression() || someExpression();
-									//
-									// the generated code is:
-									//
-									//   false && someExpression();
-									//
+									// Expressions do not hoist, so the dead branch is safe to remove.
+									// Whichever side cannot decide the result is replaced, leaving the
+									// deciding side and its side effects in place.
 									const keepRight =
 										(expression.operator === "&&" && bool) ||
 										(expression.operator === "||" && !bool);
@@ -305,14 +256,8 @@ class ConstPlugin {
 										!param.couldHaveSideEffects() &&
 										(param.isBoolean() || keepRight)
 									) {
-										// for case like
-										//
-										//   return'development'===process.env.NODE_ENV&&'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnfalse&&'foo'
-										//
+										// The bool needs a leading space: `return'a'===b&&'foo'` would
+										// otherwise become `returnfalse&&'foo'`.
 										const dep = new ConstDependency(
 											` ${bool}`,
 											/** @type {Range} */ (param.range)
@@ -336,36 +281,12 @@ class ConstPlugin {
 								const param = parser.evaluateExpression(expression.left);
 								const keepRight = param.asNullish();
 								if (typeof keepRight === "boolean") {
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nonNullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   nonNullish ?? 0;
-									//
-									// ------------------------------------------
-									//
-									// Given the following code:
-									//
-									//   nullish ?? someExpression();
-									//
-									// the generated code is:
-									//
-									//   null ?? someExpression();
-									//
+									// `nonNullish ?? x` becomes `nonNullish ?? 0`, and `nullish ?? x`
+									// becomes `null ?? x`: the unreachable side is replaced.
 									if (!param.couldHaveSideEffects() && keepRight) {
 										// cspell:word returnnull
-										// for case like
-										//
-										//   return('development'===process.env.NODE_ENV&&null)??'foo'
-										//
-										// we need a space before the bool to prevent result like
-										//
-										//   returnnull??'foo'
-										//
+										// As above, the value needs a leading space, or `return(…&&null)`
+										// would become `returnnull??'foo'`.
 										const dep = new ConstDependency(
 											" null",
 											/** @type {Range} */ (param.range)
@@ -423,18 +344,8 @@ class ConstPlugin {
 							);
 
 							if (evaluated.asNullish()) {
-								// ------------------------------------------
-								//
-								// Given the following code:
-								//
-								//   nullishMemberChain?.a.b();
-								//
-								// the generated code is:
-								//
-								//   undefined;
-								//
-								// ------------------------------------------
-								//
+								// A nullish chain short-circuits whole, so `nullish?.a.b()`
+								// becomes `undefined`.
 								const dep = new ConstDependency(
 									" undefined",
 									/** @type {Range} */ (expr.range)
@@ -519,36 +430,9 @@ class ConstPlugin {
 	 * @returns {void}
 	 */
 	eliminateUnusedStatement(parser, statement, alwaysInBlock) {
-		// Before removing the unused branch, the hoisted declarations
-		// must be collected.
-		//
-		// Given the following code:
-		//
-		//     if (true) f() else g()
-		//     if (false) {
-		//       function f() {}
-		//       const g = function g() {}
-		//       if (someTest) {
-		//         let a = 1
-		//         var x, {y, z} = obj
-		//       }
-		//     } else {
-		//       …
-		//     }
-		//
-		// the generated code is:
-		//
-		//     if (true) f() else {}
-		//     if (false) {
-		//       var f, x, y, z;   (in loose mode)
-		//       var x, y, z;      (in strict mode)
-		//     } else {
-		//       …
-		//     }
-		//
-		// NOTE: When code runs in strict mode, `var` declarations
-		// are hoisted but `function` declarations don't.
-		//
+		// The hoisted declarations must be collected before the unused branch goes,
+		// since the removed code still contributes them. In strict mode `var` is
+		// hoisted but `function` is not, so the two modes collect different sets.
 		const declarations = parser.scope.isStrict
 			? getHoistedDeclarations(statement, false)
 			: getHoistedDeclarations(statement, true);