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

package/lib/javascript/JavascriptParser.js

@@ -22,110 +22,120 @@ const {
 	WebpackParser,
 	buildLineStarts,
 	hasOctalEscape,
+	isIdentifierChar,
 	positionAt
 } = require("./syntax");
 
 /** @typedef {typeof import("acorn").Parser} AcornParser */
-/** @typedef {import("acorn").Options} AcornOptions */
-/** @typedef {import("acorn").ecmaVersion} EcmaVersion */
-/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
-/** @typedef {import("estree").BinaryExpression} BinaryExpression */
-/** @typedef {import("estree").BlockStatement} BlockStatement */
-/** @typedef {import("estree").SequenceExpression} SequenceExpression */
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").StaticBlock} StaticBlock */
-/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
-/** @typedef {import("estree").ForStatement} ForStatement */
-/** @typedef {import("estree").SwitchStatement} SwitchStatement */
-/** @typedef {import("estree").ClassExpression} ClassExpression */
-/** @typedef {import("estree").SourceLocation} SourceLocation */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
+/**
+ * @import {
+ * 	Options as AcornOptions,
+ * 	ecmaVersion as EcmaVersion
+ * } from "acorn"
+ */
+/**
+ * @import {
+ * 	AssignmentExpression,
+ * 	BinaryExpression,
+ * 	BlockStatement,
+ * 	SequenceExpression,
+ * 	CallExpression,
+ * 	StaticBlock,
+ * 	ClassDeclaration,
+ * 	ForStatement,
+ * 	SwitchStatement,
+ * 	ClassExpression,
+ * 	SourceLocation,
+ * 	ConditionalExpression,
+ * 	Declaration,
+ * 	PrivateIdentifier,
+ * 	PropertyDefinition,
+ * 	Expression,
+ * 	ImportDeclaration,
+ * 	Identifier,
+ * 	VariableDeclaration,
+ * 	IfStatement,
+ * 	LabeledStatement,
+ * 	Literal,
+ * 	LogicalExpression,
+ * 	ChainExpression,
+ * 	MemberExpression,
+ * 	YieldExpression,
+ * 	MetaProperty,
+ * 	Property,
+ * 	AssignmentPattern,
+ * 	Pattern,
+ * 	UpdateExpression,
+ * 	ObjectExpression,
+ * 	UnaryExpression,
+ * 	ArrayExpression,
+ * 	ArrayPattern,
+ * 	AwaitExpression,
+ * 	ThisExpression,
+ * 	RestElement,
+ * 	ObjectPattern,
+ * 	SwitchCase,
+ * 	CatchClause,
+ * 	VariableDeclarator,
+ * 	ForInStatement,
+ * 	ForOfStatement,
+ * 	ReturnStatement,
+ * 	WithStatement,
+ * 	ThrowStatement,
+ * 	MethodDefinition,
+ * 	NewExpression,
+ * 	SpreadElement,
+ * 	FunctionExpression,
+ * 	WhileStatement,
+ * 	ArrowFunctionExpression,
+ * 	ExpressionStatement,
+ * 	ExportAllDeclaration,
+ * 	ExportNamedDeclaration,
+ * 	FunctionDeclaration,
+ * 	DoWhileStatement,
+ * 	TryStatement,
+ * 	Node,
+ * 	Program,
+ * 	Directive,
+ * 	Statement,
+ * 	ExportDefaultDeclaration,
+ * 	Super,
+ * 	TaggedTemplateExpression,
+ * 	TemplateLiteral,
+ * 	ModuleDeclaration,
+ * 	MaybeNamedFunctionDeclaration,
+ * 	MaybeNamedClassDeclaration
+ * } from "estree"
+ */
+/** @import { DependencyLocation } from "../Dependency" */
 /** @typedef {import("estree").Comment & { start: number, end: number, loc?: SourceLocation | null }} Comment */
-/** @typedef {import("estree").ConditionalExpression} ConditionalExpression */
-/** @typedef {import("estree").Declaration} Declaration */
-/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
-/** @typedef {import("estree").PropertyDefinition} PropertyDefinition */
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").ImportAttribute} ImportAttribute */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
-/** @typedef {import("estree").IfStatement} IfStatement */
-/** @typedef {import("estree").LabeledStatement} LabeledStatement */
-/** @typedef {import("estree").Literal} Literal */
-/** @typedef {import("estree").LogicalExpression} LogicalExpression */
-/** @typedef {import("estree").ChainExpression} ChainExpression */
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").YieldExpression} YieldExpression */
-/** @typedef {import("estree").MetaProperty} MetaProperty */
-/** @typedef {import("estree").Property} Property */
-/** @typedef {import("estree").AssignmentPattern} AssignmentPattern */
-/** @typedef {import("estree").Pattern} Pattern */
-/** @typedef {import("estree").UpdateExpression} UpdateExpression */
-/** @typedef {import("estree").ObjectExpression} ObjectExpression */
-/** @typedef {import("estree").UnaryExpression} UnaryExpression */
-/** @typedef {import("estree").ArrayExpression} ArrayExpression */
-/** @typedef {import("estree").ArrayPattern} ArrayPattern */
-/** @typedef {import("estree").AwaitExpression} AwaitExpression */
-/** @typedef {import("estree").ThisExpression} ThisExpression */
-/** @typedef {import("estree").RestElement} RestElement */
-/** @typedef {import("estree").ObjectPattern} ObjectPattern */
-/** @typedef {import("estree").SwitchCase} SwitchCase */
-/** @typedef {import("estree").CatchClause} CatchClause */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
-/** @typedef {import("estree").ForInStatement} ForInStatement */
-/** @typedef {import("estree").ForOfStatement} ForOfStatement */
-/** @typedef {import("estree").ReturnStatement} ReturnStatement */
-/** @typedef {import("estree").WithStatement} WithStatement */
-/** @typedef {import("estree").ThrowStatement} ThrowStatement */
-/** @typedef {import("estree").MethodDefinition} MethodDefinition */
-/** @typedef {import("estree").NewExpression} NewExpression */
-/** @typedef {import("estree").SpreadElement} SpreadElement */
-/** @typedef {import("estree").FunctionExpression} FunctionExpression */
-/** @typedef {import("estree").WhileStatement} WhileStatement */
-/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
-/** @typedef {import("estree").ExpressionStatement} ExpressionStatement */
-/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
-/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
-/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
-/** @typedef {import("estree").DoWhileStatement} DoWhileStatement */
-/** @typedef {import("estree").TryStatement} TryStatement */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").Program} Program */
-/** @typedef {import("estree").Directive} Directive */
-/** @typedef {import("estree").Statement} Statement */
-/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */
-/** @typedef {import("estree").Super} Super */
-/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression */
-/** @typedef {import("estree").TemplateLiteral} TemplateLiteral */
-/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
-/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
-/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
 /**
  * Defines the shared type used by this module.
  * @template T
  * @typedef {import("tapable").AsArray<T>} AsArray<T>
  */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @import { ParserState, PreparsedAst } from "../Parser" */
 
-/** @typedef {import("../dependencies/LocalModule")} LocalModule */
-/** @typedef {import("../dependencies/HarmonyExportImportedSpecifierDependency").HarmonyStarExportsList} HarmonyStarExportsList */
+/** @import LocalModule from "../dependencies/LocalModule" */
+/**
+ * @import {
+ * 	HarmonyStarExportsList
+ * } from "../dependencies/HarmonyExportImportedSpecifierDependency"
+ */
 
 /**
  * Defines the known javascript parser state type used by this module.
  * @typedef {object} KnownJavascriptParserState
  * @property {Set<string>=} harmonyNamedExports
- * @property {HarmonyStarExportsList=} harmonyStarExports
+ * @property {InstanceType<HarmonyStarExportsList>=} harmonyStarExports
  * @property {number=} lastHarmonyImportOrder
  * @property {LocalModule[]=} localModules
  */
 
 /** @typedef {ParserState & KnownJavascriptParserState} JavascriptParserState */
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Module")} Module */
+/** @import Compilation from "../Compilation" */
+/** @import Module from "../Module" */
 
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} GetInfoResult */
 /** @typedef {{ consequent?: EXPECTED_OBJECT, alternate?: EXPECTED_OBJECT }} GuardCollection per-branch guard frames pushed onto the parser state guard stack */
@@ -337,11 +347,19 @@ class VariableInfo {
 
 /** @typedef {symbol} Tag */
 
-/** @typedef {import("../dependencies/HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
-/** @typedef {import("../dependencies/ImportParserPlugin").ImportSettings} ImportSettings */
-/** @typedef {import("../dependencies/CommonJsImportsParserPlugin").CommonJsImportSettings} CommonJsImportSettings */
-/** @typedef {import("../CompatibilityPlugin").CompatibilitySettings} CompatibilitySettings */
-/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
+/**
+ * @import {
+ * 	HarmonySettings
+ * } from "../dependencies/HarmonyImportDependencyParserPlugin"
+ */
+/** @import { ImportSettings } from "../dependencies/ImportParserPlugin" */
+/**
+ * @import {
+ * 	CommonJsImportSettings
+ * } from "../dependencies/CommonJsImportsParserPlugin"
+ */
+/** @import { CompatibilitySettings } from "../CompatibilityPlugin" */
+/** @import { TopLevelSymbol } from "../optimize/InnerGraph" */
 
 /** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
 /** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
@@ -495,6 +513,25 @@ const EVALUATE_AST_CACHE_LIMIT = 4096;
 
 const CLASS_NAME = "JavascriptParser";
 
+// Reserved words in strict mode, so unusable as binding names there (12.7.2).
+const STRICT_MODE_RESERVED_WORDS = new Set([
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield"
+]);
+
+const STRICT_MODE_OUTPUT_REASON =
+	"The output is an ES module, which runs in strict mode.";
+// `await` is reserved by the module goal rather than by strict mode itself.
+const MODULE_GOAL_OUTPUT_REASON =
+	'The output is an ES module, where "await" is a reserved word.';
+
 class JavascriptParser extends Parser {
 	/**
 	 * Creates an instance of JavascriptParser.
@@ -652,7 +689,7 @@ class JavascriptParser extends Parser {
 			typeof: new HookMap(() => new SyncBailHook(["expression"])),
 			/** @type {SyncBailHook<[ImportExpression, CallExpression?], boolean | void>} */
 			importCall: new SyncBailHook(["expression", "importThen"]),
-			/** @type {SyncBailHook<[Expression | ForOfStatement], boolean | void>} */
+			/** @type {SyncBailHook<[Expression | ForOfStatement | VariableDeclaration], boolean | void>} */
 			topLevelAwait: new SyncBailHook(["expression"]),
 			/** @type {HookMap<SyncBailHook<[CallExpression], boolean | void>>} */
 			call: new HookMap(() => new SyncBailHook(["expression"])),
@@ -2871,6 +2908,9 @@ class JavascriptParser extends Parser {
 	 */
 	preWalkFunctionDeclaration(statement) {
 		if (statement.id) {
+			if (this._strictInModuleOutput) {
+				this._checkStrictModeBinding(statement.id.name, statement.id);
+			}
 			this.defineVariable(statement.id.name);
 		}
 	}
@@ -3241,6 +3281,10 @@ class JavascriptParser extends Parser {
 	blockPreWalkVariableDeclaration(statement) {
 		if (statement.kind === "var") return;
 
+		if (statement.kind === "await using" && this.scope.topLevelScope === true) {
+			this.hooks.topLevelAwait.call(statement);
+		}
+
 		const hookMap =
 			statement.kind === "const"
 				? this.hooks.varDeclarationConst
@@ -3258,12 +3302,14 @@ class JavascriptParser extends Parser {
 	_preWalkVariableDeclaration(statement, hookMap) {
 		/** @type {OnIdent | undefined} */
 		let onIdent;
+		const checkStrictBindings = this._strictInModuleOutput;
 		for (const declarator of statement.declarations) {
 			if (declarator.type !== "VariableDeclarator") continue;
 			this.preWalkVariableDeclarator(declarator);
 			if (this.hooks.preDeclarator.call(declarator, statement)) continue;
 			const id = declarator.id;
 			if (id.type === "Identifier") {
+				if (checkStrictBindings) this._checkStrictModeBinding(id.name, id);
 				// fast path: plain `const x =` skips the enterPattern dispatch and
 				// the per-declaration onIdent closure (only patterns need it)
 				if (!this.callHooksForName(this.hooks.pattern, id.name, id)) {
@@ -3271,8 +3317,10 @@ class JavascriptParser extends Parser {
 				}
 			} else {
 				if (onIdent === undefined) {
-					onIdent = (name, ident) =>
+					onIdent = (name, ident) => {
+						if (checkStrictBindings) this._checkStrictModeBinding(name, ident);
 						this._defineVariableForDeclaration(name, ident, hookMap);
+					};
 				}
 				this.enterPattern(id, onIdent);
 			}
@@ -3442,6 +3490,11 @@ class JavascriptParser extends Parser {
 	 */
 	blockPreWalkClassDeclaration(statement) {
 		if (statement.id) {
+			// only `await` reaches here: acorn rejects the other names itself,
+			// since a class body is always strict even in a loose script
+			if (this._strictInModuleOutput) {
+				this._checkStrictModeBinding(statement.id.name, statement.id);
+			}
 			this.defineVariable(statement.id.name);
 		}
 	}
@@ -3522,7 +3575,10 @@ class JavascriptParser extends Parser {
 		this.inBlockScope(() => {
 			// Error binding is optional in catch clause since ECMAScript 2019
 			if (catchClause.param !== null) {
-				this.enterPattern(catchClause.param, (ident) => {
+				this.enterPattern(catchClause.param, (ident, identifier) => {
+					if (this._strictInModuleOutput) {
+						this._checkStrictModeBinding(ident, identifier);
+					}
 					this.defineVariable(ident);
 				});
 				this.walkPattern(catchClause.param);
@@ -3825,6 +3881,9 @@ class JavascriptParser extends Parser {
 
 		if (this._strictInModuleOutput) {
 			this._checkStrictModeParams(expression.params);
+			if (expression.id) {
+				this._checkStrictModeBinding(expression.id.name, expression.id);
+			}
 		}
 		this.inFunctionScope(true, scopeParams, () => {
 			for (const param of expression.params) {
@@ -3962,6 +4021,32 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Reports a binding name a loose script allows but strict-mode ESM output
+	 * rejects — the whole bundle fails to parse, so this is never merely latent.
+	 * @param {string} name binding name
+	 * @param {Statement | Expression | Identifier} node node to report the violation at
+	 */
+	_checkStrictModeBinding(name, node) {
+		if (name === "eval" || name === "arguments") {
+			this._reportStrictModeViolation(
+				`"${name}" is not allowed as a binding name`,
+				node
+			);
+		} else if (STRICT_MODE_RESERVED_WORDS.has(name)) {
+			this._reportStrictModeViolation(
+				`"${name}" is a reserved word in strict mode and is not allowed as a binding name`,
+				node
+			);
+		} else if (name === "await") {
+			this._reportStrictModeViolation(
+				'"await" is not allowed as a binding name',
+				node,
+				MODULE_GOAL_OUTPUT_REASON
+			);
+		}
+	}
+
 	/**
 	 * Reports strict-mode-only errors in a function's parameter list: a duplicate
 	 * simple parameter, or a parameter named `eval` / `arguments`.
@@ -3978,6 +4063,17 @@ class JavascriptParser extends Parser {
 					`"${name}" is not allowed as a parameter name`,
 					param
 				);
+			} else if (STRICT_MODE_RESERVED_WORDS.has(name)) {
+				this._reportStrictModeViolation(
+					`"${name}" is a reserved word in strict mode and is not allowed as a parameter name`,
+					param
+				);
+			} else if (name === "await") {
+				this._reportStrictModeViolation(
+					'"await" is not allowed as a parameter name',
+					param,
+					MODULE_GOAL_OUTPUT_REASON
+				);
 			}
 			if (seen === undefined) seen = new Set();
 			if (seen.has(name)) {
@@ -4031,10 +4127,11 @@ class JavascriptParser extends Parser {
 	 * The location is computed here, on the rare violation path only.
 	 * @param {string} reason what is not allowed
 	 * @param {Statement | Expression | Identifier} node node to report the violation at
+	 * @param {string=} outputReason why the output rejects it, defaults to strict mode
 	 */
-	_reportStrictModeViolation(reason, node) {
+	_reportStrictModeViolation(reason, node, outputReason) {
 		const diagnostic = new WebpackError(
-			`${reason}. The output is an ES module, which runs in strict mode.`
+			`${reason}. ${outputReason === undefined ? STRICT_MODE_OUTPUT_REASON : outputReason}`
 		);
 		diagnostic.loc = this.getLocation(node);
 		if (this.options.strictModeViolations === "error") {
@@ -4238,6 +4335,10 @@ class JavascriptParser extends Parser {
 	 * @param {ClassExpression} expression the class expression
 	 */
 	walkClassExpression(expression) {
+		// only `await` reaches here, as for class declarations
+		if (this._strictInModuleOutput && expression.id) {
+			this._checkStrictModeBinding(expression.id.name, expression.id);
+		}
 		this.walkClass(expression);
 	}
 
@@ -4295,6 +4396,16 @@ class JavascriptParser extends Parser {
 		};
 		const { params, type } = functionExpression;
 		const arrow = type === "ArrowFunctionExpression";
+		// the walk skips walkFunctionExpression for a called function expression
+		if (this._strictInModuleOutput) {
+			this._checkStrictModeParams(params);
+			if (type === "FunctionExpression" && functionExpression.id) {
+				this._checkStrictModeBinding(
+					functionExpression.id.name,
+					functionExpression.id
+				);
+			}
+		}
 		const renameThis = currentThis ? getVarInfo(currentThis) : null;
 		const varInfoForArgs = options.map(getVarInfo);
 		const wasTopLevel = this.scope.topLevelScope;
@@ -5657,6 +5768,37 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * Reports whether `identifier` may occur as a word in the source text of
+	 * `range`. A conservative pre-filter for expensive AST scans: `false` means
+	 * it certainly does not occur, while a match inside a comment or a string
+	 * yields `true`. Also `true` when no source text is available (preparsed
+	 * AST), so callers must stay correct without the filter.
+	 * @param {Range} range range to search
+	 * @param {string} identifier identifier to look for
+	 * @returns {boolean} false when the identifier certainly does not occur
+	 */
+	sourceMayContainIdentifier(range, identifier) {
+		const source = this._source;
+		if (source === undefined) return true;
+		const end = range[1];
+		const length = identifier.length;
+		for (
+			let index = source.indexOf(identifier, range[0]);
+			index !== -1 && index + length <= end;
+			index = source.indexOf(identifier, index + length)
+		) {
+			if (
+				(index === 0 || !isIdentifierChar(source.charCodeAt(index - 1))) &&
+				(index + length === source.length ||
+					!isIdentifierChar(source.charCodeAt(index + length)))
+			) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 	/**
 	 * First significant char code at or after `pos`, skipping whitespace,
 	 * comments and grouping `)` (a parenthesized node's range excludes its
@@ -6330,12 +6472,13 @@ class JavascriptParser extends Parser {
 	}
 }
 
-module.exports = JavascriptParser;
-module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
-module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
+JavascriptParser.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
+JavascriptParser.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
 	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
-module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
+JavascriptParser.ALLOWED_MEMBER_TYPES_EXPRESSION =
 	ALLOWED_MEMBER_TYPES_EXPRESSION;
-module.exports.VariableInfo = VariableInfo;
-module.exports.VariableInfoFlags = VariableInfoFlags;
-module.exports.getImportAttributes = getImportAttributes;
+JavascriptParser.VariableInfo = VariableInfo;
+JavascriptParser.VariableInfoFlags = VariableInfoFlags;
+JavascriptParser.getImportAttributes = getImportAttributes;
+
+module.exports = JavascriptParser;

package/lib/javascript/JavascriptParserHelpers.js

@@ -6,14 +6,17 @@
 "use strict";
 
 const ConstDependency = require("../dependencies/ConstDependency");
-const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
+const memoize = require("../util/memoize");
+
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").SourceLocation} SourceLocation */
-/** @typedef {import("./JavascriptParser")} JavascriptParser */
-/** @typedef {import("./JavascriptParser").Range} Range */
-/** @typedef {import("./BasicEvaluatedExpression").GetMembers} GetMembers */
+const getUnsupportedFeatureWarning = memoize(() =>
+	require("../errors/UnsupportedFeatureWarning")
+);
+
+/** @import { Expression } from "estree" */
+/** @import JavascriptParser, { Range } from "./JavascriptParser" */
+/** @import { GetMembers } from "./BasicEvaluatedExpression" */
 
 module.exports.approve = () => true;
 
@@ -104,7 +107,7 @@ module.exports.expressionIsUnsupported = (parser, message) =>
 		parser.state.module.addPresentationalDependency(dep);
 		if (!parser.state.module) return;
 		parser.state.module.addWarning(
-			new UnsupportedFeatureWarning(message, parser.getLocation(expr))
+			new (getUnsupportedFeatureWarning())(message, parser.getLocation(expr))
 		);
 		return true;
 	};