webpack 4.15.0 → 4.16.2

package/lib/wasm/WebAssemblyJavascriptGenerator.js

@@ -1,133 +1,147 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Generator = require("../Generator");
-const Template = require("../Template");
-const { RawSource } = require("webpack-sources");
-const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
-
-class WebAssemblyJavascriptGenerator extends Generator {
-	generate(module, dependencyTemplates, runtimeTemplate) {
-		const initIdentifer = Array.isArray(module.usedExports)
-			? Template.numberToIdentifer(module.usedExports.length)
-			: "__webpack_init__";
-
-		let needExportsCopy = false;
-		const importedModules = new Map();
-		const initParams = [];
-		let index = 0;
-		for (const dep of module.dependencies) {
-			if (dep.module) {
-				let importData = importedModules.get(dep.module);
-				if (importData === undefined) {
-					importedModules.set(
-						dep.module,
-						(importData = {
-							importVar: `m${index}`,
-							index,
-							request: dep.userRequest,
-							names: new Set(),
-							reexports: []
-						})
-					);
-					index++;
-				}
-				if (dep instanceof WebAssemblyImportDependency) {
-					importData.names.add(dep.name);
-					if (dep.description.type === "GlobalType") {
-						const exportName = dep.name;
-						const usedName = dep.module && dep.module.isUsed(exportName);
-
-						if (dep.module) {
-							if (usedName) {
-								initParams.push(
-									runtimeTemplate.exportFromImport({
-										module: dep.module,
-										request: dep.request,
-										importVar: importData.importVar,
-										originModule: module,
-										exportName: dep.name,
-										asiSafe: true,
-										isCall: false,
-										callContext: null
-									})
-								);
-							}
-						}
-					}
-				}
-				if (dep instanceof WebAssemblyExportImportedDependency) {
-					importData.names.add(dep.name);
-					const usedName = module.isUsed(dep.exportName);
-					if (usedName) {
-						const defineStatement = Template.asString([
-							`${module.exportsArgument}[${JSON.stringify(
-								usedName
-							)}] = ${runtimeTemplate.exportFromImport({
-								module: dep.module,
-								request: dep.request,
-								importVar: importData.importVar,
-								originModule: module,
-								exportName: dep.name,
-								asiSafe: true,
-								isCall: false,
-								callContext: null
-							})};`
-						]);
-						importData.reexports.push(defineStatement);
-						needExportsCopy = true;
-					}
-				}
-			}
-		}
-		const importsCode = Template.asString(
-			Array.from(
-				importedModules,
-				([module, { importVar, request, reexports }]) => {
-					const importStatement = runtimeTemplate.importStatement({
-						module,
-						request,
-						importVar,
-						originModule: module
-					});
-					return importStatement + reexports.join("\n");
-				}
-			)
-		);
-
-		// create source
-		const source = new RawSource(
-			[
-				'"use strict";',
-				"// Instantiate WebAssembly module",
-				"var wasmExports = __webpack_require__.w[module.i];",
-
-				!Array.isArray(module.usedExports)
-					? `__webpack_require__.r(${module.exportsArgument});`
-					: "",
-
-				// this must be before import for circular dependencies
-				"// export exports from WebAssembly module",
-				Array.isArray(module.usedExports) && !needExportsCopy
-					? `${module.moduleArgument}.exports = wasmExports;`
-					: "for(var name in wasmExports) " +
-					  `if(name != ${JSON.stringify(initIdentifer)}) ` +
-					  `${module.exportsArgument}[name] = wasmExports[name];`,
-				"// exec imports from WebAssembly module (for esm order)",
-				importsCode,
-				"",
-				"// exec wasm module",
-				`wasmExports[${JSON.stringify(initIdentifer)}](${initParams.join(
-					", "
-				)})`
-			].join("\n")
-		);
-		return source;
-	}
-}
-
-module.exports = WebAssemblyJavascriptGenerator;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Generator = require("../Generator");
+const Template = require("../Template");
+const { RawSource } = require("webpack-sources");
+const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
+
+/** @typedef {import("../NormalModule")} NormalModule */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Dependency").DependencyTemplate} DependencyTemplate */
+
+class WebAssemblyJavascriptGenerator extends Generator {
+	/**
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {Map<Function, DependencyTemplate>} dependencyTemplates mapping from dependencies to templates
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @param {string} type which kind of code should be generated
+	 * @returns {Source} generated code
+	 */
+	generate(module, dependencyTemplates, runtimeTemplate, type) {
+		const initIdentifer = Array.isArray(module.usedExports)
+			? Template.numberToIdentifer(module.usedExports.length)
+			: "__webpack_init__";
+
+		let needExportsCopy = false;
+		const importedModules = new Map();
+		const initParams = [];
+		let index = 0;
+		for (const dep of module.dependencies) {
+			const depAsAny = /** @type {any} */ (dep);
+			if (dep.module) {
+				let importData = importedModules.get(dep.module);
+				if (importData === undefined) {
+					importedModules.set(
+						dep.module,
+						(importData = {
+							importVar: `m${index}`,
+							index,
+							request:
+								"userRequest" in depAsAny ? depAsAny.userRequest : undefined,
+							names: new Set(),
+							reexports: []
+						})
+					);
+					index++;
+				}
+				if (dep instanceof WebAssemblyImportDependency) {
+					importData.names.add(dep.name);
+					if (dep.description.type === "GlobalType") {
+						const exportName = dep.name;
+						const usedName = dep.module && dep.module.isUsed(exportName);
+
+						if (dep.module) {
+							if (usedName) {
+								initParams.push(
+									runtimeTemplate.exportFromImport({
+										module: dep.module,
+										request: dep.request,
+										importVar: importData.importVar,
+										originModule: module,
+										exportName: dep.name,
+										asiSafe: true,
+										isCall: false,
+										callContext: null
+									})
+								);
+							}
+						}
+					}
+				}
+				if (dep instanceof WebAssemblyExportImportedDependency) {
+					importData.names.add(dep.name);
+					const usedName = module.isUsed(dep.exportName);
+					if (usedName) {
+						const defineStatement = Template.asString([
+							`${module.exportsArgument}[${JSON.stringify(
+								usedName
+							)}] = ${runtimeTemplate.exportFromImport({
+								module: dep.module,
+								request: dep.request,
+								importVar: importData.importVar,
+								originModule: module,
+								exportName: dep.name,
+								asiSafe: true,
+								isCall: false,
+								callContext: null
+							})};`
+						]);
+						importData.reexports.push(defineStatement);
+						needExportsCopy = true;
+					}
+				}
+			}
+		}
+		const importsCode = Template.asString(
+			Array.from(
+				importedModules,
+				([module, { importVar, request, reexports }]) => {
+					const importStatement = runtimeTemplate.importStatement({
+						module,
+						request,
+						importVar,
+						originModule: module
+					});
+					return importStatement + reexports.join("\n");
+				}
+			)
+		);
+
+		// create source
+		const source = new RawSource(
+			[
+				'"use strict";',
+				"// Instantiate WebAssembly module",
+				"var wasmExports = __webpack_require__.w[module.i];",
+
+				!Array.isArray(module.usedExports)
+					? `__webpack_require__.r(${module.exportsArgument});`
+					: "",
+
+				// this must be before import for circular dependencies
+				"// export exports from WebAssembly module",
+				Array.isArray(module.usedExports) && !needExportsCopy
+					? `${module.moduleArgument}.exports = wasmExports;`
+					: "for(var name in wasmExports) " +
+					  `if(name != ${JSON.stringify(initIdentifer)}) ` +
+					  `${module.exportsArgument}[name] = wasmExports[name];`,
+				"// exec imports from WebAssembly module (for esm order)",
+				importsCode,
+				"",
+				"// exec wasm module",
+				`wasmExports[${JSON.stringify(initIdentifer)}](${initParams.join(
+					", "
+				)})`
+			].join("\n")
+		);
+		return source;
+	}
+}
+
+module.exports = WebAssemblyJavascriptGenerator;

package/lib/wasm/WebAssemblyParser.js

@@ -1,174 +1,174 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const t = require("@webassemblyjs/ast");
-const { decode } = require("@webassemblyjs/wasm-parser");
-const {
-	moduleContextFromModuleAST
-} = require("@webassemblyjs/helper-module-context");
-
-const { Tapable } = require("tapable");
-const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
-
-/** @typedef {import("../Module")} Module */
-
-const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
-
-/**
- * @param {t.Signature} signature the func signature
- * @returns {null | string} the type incompatible with js types
- */
-const getJsIncompatibleType = signature => {
-	for (const param of signature.params) {
-		if (!JS_COMPAT_TYPES.has(param.valtype)) {
-			return `${param.valtype} as parameter`;
-		}
-	}
-	for (const type of signature.results) {
-		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
-	}
-	return null;
-};
-
-/**
- * TODO why are there two different Signature types?
- * @param {t.FuncSignature} signature the func signature
- * @returns {null | string} the type incompatible with js types
- */
-const getJsIncompatibleTypeOfFuncSignature = signature => {
-	for (const param of signature.args) {
-		if (!JS_COMPAT_TYPES.has(param)) {
-			return `${param} as parameter`;
-		}
-	}
-	for (const type of signature.result) {
-		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
-	}
-	return null;
-};
-
-const decoderOpts = {
-	ignoreCodeSection: true,
-	ignoreDataSection: true,
-
-	// this will avoid having to lookup with identifiers in the ModuleContext
-	ignoreCustomNameSection: true
-};
-
-class WebAssemblyParser extends Tapable {
-	constructor(options) {
-		super();
-		this.hooks = {};
-		this.options = options;
-	}
-
-	parse(binary, state) {
-		// flag it as ESM
-		state.module.buildMeta.exportsType = "namespace";
-
-		// parse it
-		const program = decode(binary, decoderOpts);
-		const module = program.body[0];
-
-		const moduleContext = moduleContextFromModuleAST(module);
-
-		// extract imports and exports
-		const exports = (state.module.buildMeta.providedExports = []);
-		const jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports = []);
-
-		const importedGlobals = [];
-		t.traverse(module, {
-			ModuleExport({ node }) {
-				const descriptor = node.descr;
-
-				if (descriptor.exportType === "Func") {
-					const funcidx = descriptor.id.value;
-
-					/** @type {t.FuncSignature} */
-					const funcSignature = moduleContext.getFunction(funcidx);
-
-					const incompatibleType = getJsIncompatibleTypeOfFuncSignature(
-						funcSignature
-					);
-
-					if (incompatibleType) {
-						jsIncompatibleExports[node.name] = incompatibleType;
-					}
-				}
-
-				exports.push(node.name);
-
-				if (node.descr && node.descr.exportType === "Global") {
-					const refNode = importedGlobals[node.descr.id.value];
-					if (refNode) {
-						const dep = new WebAssemblyExportImportedDependency(
-							node.name,
-							refNode.module,
-							refNode.name
-						);
-
-						state.module.addDependency(dep);
-					}
-				}
-			},
-
-			Global({ node }) {
-				const init = node.init[0];
-
-				let importNode = null;
-
-				if (init.id === "get_global") {
-					const globalIdx = init.args[0].value;
-
-					if (globalIdx < importedGlobals.length) {
-						importNode = importedGlobals[globalIdx];
-					}
-				}
-
-				importedGlobals.push(importNode);
-			},
-
-			ModuleImport({ node }) {
-				/** @type {false | string} */
-				let onlyDirectImport = false;
-
-				if (t.isMemory(node.descr) === true) {
-					onlyDirectImport = "Memory";
-				} else if (t.isTable(node.descr) === true) {
-					onlyDirectImport = "Table";
-				} else if (t.isFuncImportDescr(node.descr) === true) {
-					const incompatibleType = getJsIncompatibleType(node.descr.signature);
-					if (incompatibleType) {
-						onlyDirectImport = `Non-JS-compatible Func Sigurature (${incompatibleType})`;
-					}
-				} else if (t.isGlobalType(node.descr) === true) {
-					const type = node.descr.valtype;
-					if (!JS_COMPAT_TYPES.has(type)) {
-						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
-					}
-				}
-
-				const dep = new WebAssemblyImportDependency(
-					node.module,
-					node.name,
-					node.descr,
-					onlyDirectImport
-				);
-
-				state.module.addDependency(dep);
-
-				if (t.isGlobalType(node.descr)) {
-					importedGlobals.push(node);
-				}
-			}
-		});
-
-		return state;
-	}
-}
-
-module.exports = WebAssemblyParser;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const t = require("@webassemblyjs/ast");
+const { decode } = require("@webassemblyjs/wasm-parser");
+const {
+	moduleContextFromModuleAST
+} = require("@webassemblyjs/helper-module-context");
+
+const { Tapable } = require("tapable");
+const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
+
+/** @typedef {import("../Module")} Module */
+
+const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
+
+/**
+ * @param {t.Signature} signature the func signature
+ * @returns {null | string} the type incompatible with js types
+ */
+const getJsIncompatibleType = signature => {
+	for (const param of signature.params) {
+		if (!JS_COMPAT_TYPES.has(param.valtype)) {
+			return `${param.valtype} as parameter`;
+		}
+	}
+	for (const type of signature.results) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
+};
+
+/**
+ * TODO why are there two different Signature types?
+ * @param {t.FuncSignature} signature the func signature
+ * @returns {null | string} the type incompatible with js types
+ */
+const getJsIncompatibleTypeOfFuncSignature = signature => {
+	for (const param of signature.args) {
+		if (!JS_COMPAT_TYPES.has(param)) {
+			return `${param} as parameter`;
+		}
+	}
+	for (const type of signature.result) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
+};
+
+const decoderOpts = {
+	ignoreCodeSection: true,
+	ignoreDataSection: true,
+
+	// this will avoid having to lookup with identifiers in the ModuleContext
+	ignoreCustomNameSection: true
+};
+
+class WebAssemblyParser extends Tapable {
+	constructor(options) {
+		super();
+		this.hooks = {};
+		this.options = options;
+	}
+
+	parse(binary, state) {
+		// flag it as ESM
+		state.module.buildMeta.exportsType = "namespace";
+
+		// parse it
+		const program = decode(binary, decoderOpts);
+		const module = program.body[0];
+
+		const moduleContext = moduleContextFromModuleAST(module);
+
+		// extract imports and exports
+		const exports = (state.module.buildMeta.providedExports = []);
+		const jsIncompatibleExports = (state.module.buildMeta.jsIncompatibleExports = []);
+
+		const importedGlobals = [];
+		t.traverse(module, {
+			ModuleExport({ node }) {
+				const descriptor = node.descr;
+
+				if (descriptor.exportType === "Func") {
+					const funcidx = descriptor.id.value;
+
+					/** @type {t.FuncSignature} */
+					const funcSignature = moduleContext.getFunction(funcidx);
+
+					const incompatibleType = getJsIncompatibleTypeOfFuncSignature(
+						funcSignature
+					);
+
+					if (incompatibleType) {
+						jsIncompatibleExports[node.name] = incompatibleType;
+					}
+				}
+
+				exports.push(node.name);
+
+				if (node.descr && node.descr.exportType === "Global") {
+					const refNode = importedGlobals[node.descr.id.value];
+					if (refNode) {
+						const dep = new WebAssemblyExportImportedDependency(
+							node.name,
+							refNode.module,
+							refNode.name
+						);
+
+						state.module.addDependency(dep);
+					}
+				}
+			},
+
+			Global({ node }) {
+				const init = node.init[0];
+
+				let importNode = null;
+
+				if (init.id === "get_global") {
+					const globalIdx = init.args[0].value;
+
+					if (globalIdx < importedGlobals.length) {
+						importNode = importedGlobals[globalIdx];
+					}
+				}
+
+				importedGlobals.push(importNode);
+			},
+
+			ModuleImport({ node }) {
+				/** @type {false | string} */
+				let onlyDirectImport = false;
+
+				if (t.isMemory(node.descr) === true) {
+					onlyDirectImport = "Memory";
+				} else if (t.isTable(node.descr) === true) {
+					onlyDirectImport = "Table";
+				} else if (t.isFuncImportDescr(node.descr) === true) {
+					const incompatibleType = getJsIncompatibleType(node.descr.signature);
+					if (incompatibleType) {
+						onlyDirectImport = `Non-JS-compatible Func Sigurature (${incompatibleType})`;
+					}
+				} else if (t.isGlobalType(node.descr) === true) {
+					const type = node.descr.valtype;
+					if (!JS_COMPAT_TYPES.has(type)) {
+						onlyDirectImport = `Non-JS-compatible Global Type (${type})`;
+					}
+				}
+
+				const dep = new WebAssemblyImportDependency(
+					node.module,
+					node.name,
+					node.descr,
+					onlyDirectImport
+				);
+
+				state.module.addDependency(dep);
+
+				if (t.isGlobalType(node.descr)) {
+					importedGlobals.push(node);
+				}
+			}
+		});
+
+		return state;
+	}
+}
+
+module.exports = WebAssemblyParser;