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

package/lib/javascript/JavascriptModulesPlugin.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const vm = require("vm");
-const eslintScope = require("eslint-scope");
 const { SyncBailHook, SyncHook, SyncWaterfallHook } = require("tapable");
 const {
 	CachedSource,
@@ -16,7 +15,13 @@ const {
 	RawSource,
 	ReplaceSource
 } = require("webpack-sources");
-/** @typedef {import("../Compilation")} Compilation */
+/**
+ * @import Compilation, {
+ * 	ChunkHashContext,
+ * 	ExecuteModuleObject,
+ * 	WebpackRequire
+ * } from "../Compilation"
+ */
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
@@ -34,6 +39,7 @@ const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByFullName } = require("../util/comparators");
 const {
+	CHUNK_RUNTIME_DECLARATIONS,
 	RESERVED_NAMES,
 	addScopeSymbols,
 	findNewName,
@@ -50,103 +56,54 @@ const { getAllChunks } = require("./ChunkHelpers");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptModule = require("./JavascriptModule");
 const JavascriptParser = require("./JavascriptParser");
-
-/** @typedef {import("estree").Program} Program */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").CatchClause} CatchClause */
-/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
-/** @typedef {import("estree").ClassExpression} ClassExpression */
-/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
-/** @typedef {import("estree").FunctionExpression} FunctionExpression */
-/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
-/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
-/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
-/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */
-/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */
-/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
-/** @typedef {import("estree").ForInStatement} ForInStatement */
-/** @typedef {import("estree").ForOfStatement} ForOfStatement */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compilation").ExecuteModuleObject} ExecuteModuleObject */
-/** @typedef {import("../Compilation").WebpackRequire} WebpackRequire */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/concatenate").ScopeSet} ScopeSet */
-/** @typedef {import("../util/concatenate").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
-
-// TODO remove these types when we will update `eslint-scope` to the latest version and import them from `eslint-scope`
-/**
- * @typedef {object} Scope
- * @property {"block" | "catch" | "class" | "class-field-initializer" | "class-static-block" | "for" | "function" | "function-expression-name" | "global" | "module" | "switch" | "with" | "TDZ"} type
- * @property {boolean} isStrict
- * @property {Scope | null} upper
- * @property {Scope[]} childScopes
- * @property {Scope} variableScope
- * @property {Node} block
- * @property {Variable[]} variables
- * @property {Map<string, Variable>} set
- * @property {Reference[]} references
- * @property {Reference[]} through
- * @property {boolean} functionExpressionScope
- * @property {{ variables: Variable[], set: Map<string, Variable> }=} implicit
- */
-
-/**
- * @typedef {
- * | { type: "CatchClause", node: CatchClause, parent: null }
- * | { type: "ClassName", node: ClassDeclaration | ClassExpression, parent: null }
- * | { type: "FunctionName", node: FunctionDeclaration | FunctionExpression, parent: null }
- * | { type: "ImplicitGlobalVariable", node: AssignmentExpression | ForInStatement | ForOfStatement, parent: null }
- * | { type: "ImportBinding", node: ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier, parent: ImportDeclaration }
- * | { type: "Parameter", node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, parent: null }
- * | { type: "TDZ", node: any, parent: null }
- * | { type: "Variable", node: VariableDeclarator, parent: VariableDeclaration }
- * } DefinitionType
- */
-
-/** @typedef {DefinitionType & { name: Identifier }} Definition */
+const analyzeScope = require("./ScopeAnalyzer");
 
 /**
- * @typedef {object} Variable
- * @property {string} name
- * @property {Scope} scope
- * @property {Identifier[]} identifiers
- * @property {Reference[]} references
- * @property {Definition[]} defs
+ * @import {
+ * 	Program,
+ * 	Node,
+ * 	Identifier,
+ * 	CatchClause,
+ * 	ClassDeclaration,
+ * 	ClassExpression,
+ * 	FunctionDeclaration,
+ * 	FunctionExpression,
+ * 	ArrowFunctionExpression,
+ * 	VariableDeclarator,
+ * 	VariableDeclaration,
+ * 	ImportDeclaration,
+ * 	ImportSpecifier,
+ * 	ImportDefaultSpecifier,
+ * 	ImportNamespaceSpecifier,
+ * 	AssignmentExpression,
+ * 	ForInStatement,
+ * 	ForOfStatement
+ * } from "estree"
  */
-
+/** @import { Source } from "webpack-sources" */
 /**
- * @typedef {object} Reference
- * @property {Identifier} identifier
- * @property {Scope} from
- * @property {Variable | null} resolved
- * @property {Node | null} writeExpr
- * @property {boolean} init
- * @property {() => boolean} isWrite
- * @property {() => boolean} isRead
- * @property {() => boolean} isWriteOnly
- * @property {() => boolean} isReadOnly
- * @property {() => boolean} isReadWrite
+ * @import {
+ * 	OutputNormalizedWithDefaults as OutputOptions
+ * } from "../config/defaults"
  */
+/** @import Chunk, { ChunkFilenameTemplate } from "../Chunk" */
+/** @import ChunkGraph, { EntryModuleWithChunkGroup } from "../ChunkGraph" */
+/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import Compiler from "../Compiler" */
+/** @import DependencyTemplates from "../DependencyTemplates" */
+/** @import Entrypoint from "../Entrypoint" */
+/** @import Module, { BuildInfo, CodeGenerationResultData } from "../Module" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import WebpackError from "../errors/WebpackError" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Hash from "../util/Hash" */
+/** @import { ScopeSet, UsedNamesInScopeInfo } from "../util/concatenate" */
+
+/** @typedef {import("./ScopeAnalyzer").Scope} Scope */
+/** @typedef {import("./ScopeAnalyzer").Variable} Variable */
+/** @typedef {import("./ScopeAnalyzer").Reference} Reference */
 
 /** @type {WeakMap<ChunkGraph, WeakMap<Chunk, boolean>>} */
 const chunkHasJsCache = new WeakMap();
@@ -330,23 +287,101 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {boolean=} renderInObject render module in object container
  */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>}
+	 */
+	renderModuleContent: new SyncWaterfallHook([
+		"source",
+		"module",
+		"moduleRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>}
+	 */
+	renderModuleContainer: new SyncWaterfallHook([
+		"source",
+		"module",
+		"moduleRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>}
+	 */
+	renderModulePackage: new SyncWaterfallHook([
+		"source",
+		"module",
+		"moduleRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 */
+	render: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 * @since 5.41.0
+	 */
+	renderContent: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, StartupRenderContext]>}
+	 * @since 5.22.0
+	 */
+	renderStartup: new SyncWaterfallHook([
+		"source",
+		"module",
+		"startupRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 */
+	renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 */
+	renderMain: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, RenderBootstrapContext]>}
+	 */
+	renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
+	/**
+	 * @type {SyncBailHook<[Module, Partial<RenderBootstrapContext>], string | void>}
+	 * @since 5.22.0
+	 */
+	inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+	/**
+	 * Offers a module's rendered export-definition call to a consumer that can place
+	 * it better — a library whose entry exports the same bindings natively takes it
+	 * over and emits it only where the module is wrapped. Return true to take it.
+	 * @type {SyncBailHook<[Module, RuntimeSpec, string, boolean], boolean | void>}
+	 */
+	onDemandExportsGeneration: new SyncBailHook([
+		"module",
+		"runtime",
+		"source",
+		"placeAtEnd"
+	]),
+	/**
+	 * @type {SyncBailHook<[Module, RenderContext], string | void>}
+	 * @since 5.22.0
+	 */
+	embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+	/**
+	 * @type {SyncBailHook<[RenderContext], string | void>}
+	 * @since 5.26.1
+	 */
+	strictRuntimeBailout: new SyncBailHook(["renderContext"]),
+	/**
+	 * @type {SyncHook<[Chunk, Hash, ChunkHashContext]>}
+	 */
+	chunkHash: new SyncHook(["chunk", "hash", "context"]),
+	/**
+	 * @type {SyncBailHook<[Chunk, RenderContext], boolean | void>}
+	 * @since 5.2.1
+	 */
+	useSourceMap: new SyncBailHook(["chunk", "renderContext"])
+});
+
 /**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModulePackage
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
- * @property {SyncWaterfallHook<[Source, RenderContext]>} render
- * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
- * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
- * @property {SyncBailHook<[Module, Partial<RenderBootstrapContext>], string | void>} inlineInRuntimeBailout
- * @property {SyncBailHook<[Module, RenderContext], string | void>} embedInRuntimeBailout
- * @property {SyncBailHook<[RenderContext], string | void>} strictRuntimeBailout
- * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
- * @property {SyncBailHook<[Chunk, RenderContext], boolean | void>} useSourceMap
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
  */
 
 /**
@@ -1162,7 +1197,17 @@ class JavascriptModulesPlugin {
 			!allStrict &&
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict)
 		) {
-			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+			// a non-arrow bootstrap IIFE is called without a receiver, so in strict
+			// mode the `this` that `output.globalObject` reads would be undefined
+			const globalObjectNeedsThis =
+				iife &&
+				!runtimeTemplate.supportsArrowFunction() &&
+				runtimeTemplate.globalObjectUsesThis();
+			const strictBailout =
+				hooks.strictRuntimeBailout.call(renderContext) ||
+				(globalObjectNeedsThis
+					? "'output.globalObject' reads 'this'"
+					: undefined);
 			if (strictBailout) {
 				source.add(
 					`${prefix}// runtime can't be in strict mode because ${strictBailout}.\n`
@@ -1693,6 +1738,23 @@ class JavascriptModulesPlugin {
 						);
 						result.allowInlineStartup = false;
 					}
+					if (result.allowInlineStartup) {
+						// the bail-out above already established that one of the two
+						// sources carries them
+						const topLevelDeclarations =
+							(data && data.get("topLevelDeclarations")) ||
+							/** @type {BuildInfo} */ (entryModule.buildInfo)
+								.topLevelDeclarations;
+						for (const name of CHUNK_RUNTIME_DECLARATIONS) {
+							if (/** @type {Set<string>} */ (topLevelDeclarations).has(name)) {
+								buf2.push(
+									`// This entry module declares '${name}' on top-level, which the runtime also declares, so it can't be inlined`
+								);
+								result.allowInlineStartup = false;
+								break;
+							}
+						}
+					}
 					if (result.allowInlineStartup) {
 						const bailout = hooks.inlineInRuntimeBailout.call(
 							entryModule,
@@ -2114,15 +2176,9 @@ class JavascriptModulesPlugin {
 				JavascriptParser._getModuleParseFunction(compilation, m)
 			);
 
-			const scopeManager = eslintScope.analyze(ast, {
-				ecmaVersion: 6,
-				sourceType: "module",
-				optimistic: true,
-				ignoreEval: true
-			});
+			const analysis = analyzeScope(ast);
 
-			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
-			for (const ref of globalScope.through) {
+			for (const ref of analysis.unresolvedReferences) {
 				nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
 			}
 		}
@@ -2191,21 +2247,15 @@ class JavascriptModulesPlugin {
 				JavascriptParser._getModuleParseFunction(compilation, m)
 			);
 
-			const scopeManager = eslintScope.analyze(ast, {
-				ecmaVersion: 6,
-				sourceType: "module",
-				optimistic: true,
-				ignoreEval: true
-			});
+			const analysis = analyzeScope(ast);
 
-			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
-			const moduleScope = globalScope.childScopes[0];
+			const moduleScope = analysis.moduleScope;
 			inlinedModulesToInfo.set(m, {
 				source: moduleSource,
 				ast,
 				module: m,
 				variables: new Set(moduleScope.variables),
-				through: new Set(moduleScope.through),
+				through: new Set(analysis.unresolvedReferences),
 				usedInNonInlined: new Set(),
 				moduleScope
 			});
@@ -2288,40 +2338,9 @@ class JavascriptModulesPlugin {
 }
 
 JavascriptModulesPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			renderModuleContent: new SyncWaterfallHook([
-				"source",
-				"module",
-				"moduleRenderContext"
-			]),
-			renderModuleContainer: new SyncWaterfallHook([
-				"source",
-				"module",
-				"moduleRenderContext"
-			]),
-			renderModulePackage: new SyncWaterfallHook([
-				"source",
-				"module",
-				"moduleRenderContext"
-			]),
-			render: new SyncWaterfallHook(["source", "renderContext"]),
-			renderContent: new SyncWaterfallHook(["source", "renderContext"]),
-			renderStartup: new SyncWaterfallHook([
-				"source",
-				"module",
-				"startupRenderContext"
-			]),
-			renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
-			renderMain: new SyncWaterfallHook(["source", "renderContext"]),
-			renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
-			inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-			embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-			strictRuntimeBailout: new SyncBailHook(["renderContext"]),
-			chunkHash: new SyncHook(["chunk", "hash", "context"]),
-			useSourceMap: new SyncBailHook(["chunk", "renderContext"])
-		})
+	createCompilationHooks
 );
 
+JavascriptModulesPlugin.chunkHasJs = chunkHasJs;
+
 module.exports = JavascriptModulesPlugin;
-module.exports.chunkHasJs = chunkHasJs;