webpack 4.10.1 → 4.12.0

package/lib/wasm/WebAssemblyGenerator.js

@@ -13,6 +13,11 @@ const { shrinkPaddedLEB128 } = require("@webassemblyjs/wasm-opt");
 const { editWithAST, addWithAST } = require("@webassemblyjs/wasm-edit");
 const { decode } = require("@webassemblyjs/wasm-parser");
 const t = require("@webassemblyjs/ast");
+const {
+	moduleContextFromModuleAST
+} = require("@webassemblyjs/helper-module-context");
+
+const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
@@ -43,20 +48,6 @@ function compose(...fns) {
 	}, value => value);
 }
 
-// Utility functions
-
-/**
- * @param {t.ModuleImport} n the import
- * @returns {boolean} true, if a global was imported
- */
-const isGlobalImport = n => n.descr.type === "GlobalType";
-
-/**
- * @param {t.ModuleImport} n the import
- * @returns {boolean} true, if a func was imported
- */
-const isFuncImport = n => n.descr.type === "FuncImportDescr";
-
 // TODO replace with @callback
 
 /**
@@ -73,24 +64,6 @@ const removeStartFunc = state => bin => {
 	});
 };
 
-/**
- * Retrieve the start function
- *
- * @param {Object} ast - Module's AST
- * @returns {t.Identifier | undefined} - node if any
- */
-function getStartFuncIndex(ast) {
-	let startAtFuncIndex;
-
-	t.traverse(ast, {
-		Start({ node }) {
-			startAtFuncIndex = node.index;
-		}
-	});
-
-	return startAtFuncIndex;
-}
-
 /**
  * Get imported globals
  *
@@ -102,7 +75,7 @@ function getImportedGlobals(ast) {
 
 	t.traverse(ast, {
 		ModuleImport({ node }) {
-			if (isGlobalImport(node) === true) {
+			if (t.isGlobalType(node.descr) === true) {
 				importedGlobals.push(node);
 			}
 		}
@@ -116,7 +89,7 @@ function getCountImportedFunc(ast) {
 
 	t.traverse(ast, {
 		ModuleImport({ node }) {
-			if (isFuncImport(node) === true) {
+			if (t.isFuncImportDescr(node.descr) === true) {
 				count++;
 			}
 		}
@@ -129,7 +102,7 @@ function getCountImportedFunc(ast) {
  * Get next type index
  *
  * @param {Object} ast - Module's AST
- * @returns {t.IndexLiteral} - index
+ * @returns {t.Index} - index
  */
 function getNextTypeIndex(ast) {
 	const typeSectionMetadata = t.getSectionMetadata(ast, "type");
@@ -150,7 +123,7 @@ function getNextTypeIndex(ast) {
  *
  * @param {Object} ast - Module's AST
  * @param {Number} countImportedFunc - number of imported funcs
- * @returns {t.IndexLiteral} - index
+ * @returns {t.Index} - index
  */
 function getNextFuncIndex(ast, countImportedFunc) {
 	const funcSectionMetadata = t.getSectionMetadata(ast, "func");
@@ -164,6 +137,27 @@ function getNextFuncIndex(ast, countImportedFunc) {
 	return t.indexLiteral(vectorOfSize + countImportedFunc);
 }
 
+/**
+ * Create a init instruction for a global
+ * @param {t.GlobalType} globalType the global type
+ * @returns {t.Instruction} init expression
+ */
+const createDefaultInitForGlobal = globalType => {
+	if (globalType.valtype[0] === "i") {
+		// create NumberLiteral global initializer
+		return t.objectInstruction("const", globalType.valtype, [
+			t.numberLiteralFromRaw(66)
+		]);
+	} else if (globalType.valtype[0] === "f") {
+		// create FloatLiteral global initializer
+		return t.objectInstruction("const", globalType.valtype, [
+			t.floatLiteral(66, false, false, "66")
+		]);
+	} else {
+		throw new Error("unknown type: " + globalType.valtype);
+	}
+};
+
 /**
  * Rewrite the import globals:
  * - removes the ModuleImport instruction
@@ -178,35 +172,51 @@ function getNextFuncIndex(ast, countImportedFunc) {
  * @returns {ArrayBufferTransform} transform
  */
 const rewriteImportedGlobals = state => bin => {
+	const additionalInitCode = state.additionalInitCode;
 	const newGlobals = [];
 
 	bin = editWithAST(state.ast, bin, {
 		ModuleImport(path) {
-			if (isGlobalImport(path.node) === true) {
+			if (t.isGlobalType(path.node.descr) === true) {
 				const globalType = path.node.descr;
 
 				globalType.mutability = "var";
 
-				let init;
-
-				if (globalType.valtype[0] === "i") {
-					// create NumberLiteral global initializer
-					init = t.objectInstruction("const", globalType.valtype, [
-						t.numberLiteralFromRaw(0)
-					]);
-				} else if (globalType.valtype[0] === "f") {
-					// create FloatLiteral global initializer
-					init = t.objectInstruction("const", globalType.valtype, [
-						t.floatLiteral(0, false, false, "0")
-					]);
-				} else {
-					throw new Error("unknown type: " + globalType.valtype);
-				}
+				const init = createDefaultInitForGlobal(globalType);
 
 				newGlobals.push(t.global(globalType, [init]));
 
 				path.remove();
 			}
+		},
+
+		// in order to preserve non-imported global's order we need to re-inject
+		// those as well
+		Global(path) {
+			const { node } = path;
+			const [init] = node.init;
+
+			if (init.id === "get_global") {
+				node.globalType.mutability = "var";
+
+				const initialGlobalidx = init.args[0];
+
+				node.init = [createDefaultInitForGlobal(node.globalType)];
+
+				additionalInitCode.push(
+					/**
+					 * get_global in global initilizer only work for imported globals.
+					 * They have the same indices than the init params, so use the
+					 * same index.
+					 */
+					t.instruction("get_local", [initialGlobalidx]),
+					t.instruction("set_global", [t.indexLiteral(newGlobals.length)])
+				);
+			}
+
+			newGlobals.push(node);
+
+			path.remove();
 		}
 	});
 
@@ -218,18 +228,24 @@ const rewriteImportedGlobals = state => bin => {
  * Rewrite the export names
  * @param {Object} state state
  * @param {Object} state.ast Module's ast
- * @param {Object} state.module Module
+ * @param {Module} state.module Module
+ * @param {Set<string>} state.externalExports Module
  * @returns {ArrayBufferTransform} transform
  */
-const rewriteExportNames = ({ ast, module }) => bin => {
+const rewriteExportNames = ({ ast, module, externalExports }) => bin => {
 	return editWithAST(ast, bin, {
 		ModuleExport(path) {
+			const isExternal = externalExports.has(path.node.name);
+			if (isExternal) {
+				path.remove();
+				return;
+			}
 			const usedName = module.isUsed(path.node.name);
-			if (usedName) {
-				path.node.name = usedName;
-			} else {
+			if (!usedName) {
 				path.remove();
+				return;
 			}
+			path.node.name = usedName;
 		}
 	});
 };
@@ -247,10 +263,9 @@ const rewriteImports = ({ ast, usedDependencyMap }) => bin => {
 			const result = usedDependencyMap.get(
 				path.node.module + ":" + path.node.name
 			);
-			if (result === undefined) {
-				path.remove();
-			} else {
-				path.node.module = WebAssemblyUtils.MANGLED_MODULE;
+
+			if (typeof result !== "undefined") {
+				path.node.module = result.module;
 				path.node.name = result.name;
 			}
 		}
@@ -265,17 +280,19 @@ const rewriteImports = ({ ast, usedDependencyMap }) => bin => {
  * @param {Object} state transformation state
  * @param {Object} state.ast - Module's ast
  * @param {t.Identifier} state.initFuncId identifier of the init function
- * @param {t.IndexLiteral} state.startAtFuncIndex index of the start function
+ * @param {t.Index} state.startAtFuncOffset index of the start function
  * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
- * @param {t.IndexLiteral} state.nextFuncIndex index of the next function
- * @param {t.IndexLiteral} state.nextTypeIndex index of the next type
+ * @param {t.Instruction[]} state.additionalInitCode list of addition instructions for the init function
+ * @param {t.Index} state.nextFuncIndex index of the next function
+ * @param {t.Index} state.nextTypeIndex index of the next type
  * @returns {ArrayBufferTransform} transform
  */
 const addInitFunction = ({
 	ast,
 	initFuncId,
-	startAtFuncIndex,
+	startAtFuncOffset,
 	importedGlobals,
+	additionalInitCode,
 	nextFuncIndex,
 	nextTypeIndex
 }) => bin => {
@@ -296,8 +313,12 @@ const addInitFunction = ({
 		return [...acc, ...body];
 	}, []);
 
-	if (typeof startAtFuncIndex !== "undefined") {
-		funcBody.push(t.callInstruction(startAtFuncIndex));
+	if (typeof startAtFuncOffset === "number") {
+		funcBody.push(t.callInstruction(t.numberLiteralFromRaw(startAtFuncOffset)));
+	}
+
+	for (const instr of additionalInitCode) {
+		funcBody.push(instr);
 	}
 
 	const funcResults = [];
@@ -324,12 +345,13 @@ const addInitFunction = ({
 /**
  * Extract mangle mappings from module
  * @param {Module} module current module
+ * @param {boolean} mangle mangle imports
  * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
  */
-const getUsedDependencyMap = module => {
+const getUsedDependencyMap = (module, mangle) => {
 	/** @type {Map<string, UsedWasmDependency>} */
 	const map = new Map();
-	for (const usedDep of WebAssemblyUtils.getUsedDependencies(module)) {
+	for (const usedDep of WebAssemblyUtils.getUsedDependencies(module, mangle)) {
 		const dep = usedDep.dependency;
 		const request = dep.request;
 		const exportName = dep.name;
@@ -339,6 +361,11 @@ const getUsedDependencyMap = module => {
 };
 
 class WebAssemblyGenerator extends Generator {
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+
 	generate(module) {
 		let bin = module.originalSource().source();
 		bin = preprocess(bin);
@@ -349,29 +376,44 @@ class WebAssemblyGenerator extends Generator {
 				: "__webpack_init__"
 		);
 
+		// parse it
 		const ast = decode(bin, {
 			ignoreDataSection: true,
 			ignoreCodeSection: true,
 			ignoreCustomNameSection: true
 		});
 
+		const moduleContext = moduleContextFromModuleAST(ast.body[0]);
+
 		const importedGlobals = getImportedGlobals(ast);
 		const countImportedFunc = getCountImportedFunc(ast);
-		const startAtFuncIndex = getStartFuncIndex(ast);
+		const startAtFuncOffset = moduleContext.getStart();
 		const nextFuncIndex = getNextFuncIndex(ast, countImportedFunc);
 		const nextTypeIndex = getNextTypeIndex(ast);
 
-		const usedDependencyMap = getUsedDependencyMap(module);
+		const usedDependencyMap = getUsedDependencyMap(
+			module,
+			this.options.mangleImports
+		);
+		const externalExports = new Set(
+			module.dependencies
+				.filter(d => d instanceof WebAssemblyExportImportedDependency)
+				.map(d => d.exportName)
+		);
+
+		/** @type {t.Instruction[]} */
+		const additionalInitCode = [];
 
 		const transform = compose(
 			rewriteExportNames({
 				ast,
-				module
+				module,
+				externalExports
 			}),
 
 			removeStartFunc({ ast }),
 
-			rewriteImportedGlobals({ ast }),
+			rewriteImportedGlobals({ ast, additionalInitCode }),
 
 			rewriteImports({
 				ast,
@@ -382,7 +424,8 @@ class WebAssemblyGenerator extends Generator {
 				ast,
 				initFuncId,
 				importedGlobals,
-				startAtFuncIndex,
+				additionalInitCode,
+				startAtFuncOffset,
 				nextFuncIndex,
 				nextTypeIndex
 			})

package/lib/wasm/WebAssemblyJavascriptGenerator.js

@@ -8,34 +8,7 @@ const Generator = require("../Generator");
 const Template = require("../Template");
 const { RawSource } = require("webpack-sources");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-
-function generateInitParams(module) {
-	const list = [];
-
-	for (const dep of module.dependencies) {
-		if (dep instanceof WebAssemblyImportDependency) {
-			if (dep.description.type === "GlobalType") {
-				const exportName = dep.name;
-				const usedName = dep.module && dep.module.isUsed(exportName);
-
-				if (dep.module === null) {
-					// Dependency was not found, an error will be thrown later
-					continue;
-				}
-
-				if (usedName !== false) {
-					list.push(
-						`__webpack_require__(${JSON.stringify(
-							dep.module.id
-						)})[${JSON.stringify(usedName)}]`
-					);
-				}
-			}
-		}
-	}
-
-	return list;
-}
+const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 
 class WebAssemblyJavascriptGenerator extends Generator {
 	generate(module, dependencyTemplates, runtimeTemplate) {
@@ -43,24 +16,88 @@ class WebAssemblyJavascriptGenerator extends Generator {
 			? Template.numberToIdentifer(module.usedExports.length)
 			: "__webpack_init__";
 
-		const generateImports = () => {
-			const modules = new Map();
-			for (const dep of module.dependencies) {
-				if (dep.module) modules.set(dep.module, dep.userRequest);
-			}
-			return Template.asString(
-				Array.from(modules, ([m, r]) => {
-					return `${runtimeTemplate.moduleRaw({
-						module: m,
-						request: r
-					})};`;
-				})
-			);
-		};
+		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);
 
-		// FIXME(sven): assert that the exports exists in the modules
-		// otherwise it will default to i32 0
-		const initParams = generateInitParams(module).join(",");
+						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(
@@ -69,18 +106,24 @@ class WebAssemblyJavascriptGenerator extends Generator {
 				"// 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)
+				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)",
-				generateImports(),
-
+				importsCode,
+				"",
 				"// exec wasm module",
-				`wasmExports[${JSON.stringify(initIdentifer)}](${initParams})`
+				`wasmExports[${JSON.stringify(initIdentifer)}](${initParams.join(
+					", "
+				)})`
 			].join("\n")
 		);
 		return source;

package/lib/wasm/WebAssemblyModulesPlugin.js

@@ -9,8 +9,13 @@ const WebAssemblyParser = require("./WebAssemblyParser");
 const WebAssemblyGenerator = require("./WebAssemblyGenerator");
 const WebAssemblyJavascriptGenerator = require("./WebAssemblyJavascriptGenerator");
 const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+const WebAssemblyExportImportedDependency = require("../dependencies/WebAssemblyExportImportedDependency");
 
 class WebAssemblyModulesPlugin {
+	constructor(options) {
+		this.options = options;
+	}
+
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
 			"WebAssemblyModulesPlugin",
@@ -20,6 +25,11 @@ class WebAssemblyModulesPlugin {
 					normalModuleFactory
 				);
 
+				compilation.dependencyFactories.set(
+					WebAssemblyExportImportedDependency,
+					normalModuleFactory
+				);
+
 				normalModuleFactory.hooks.createParser
 					.for("webassembly/experimental")
 					.tap("WebAssemblyModulesPlugin", () => {
@@ -31,7 +41,7 @@ class WebAssemblyModulesPlugin {
 					.tap("WebAssemblyModulesPlugin", () => {
 						return Generator.byType({
 							javascript: new WebAssemblyJavascriptGenerator(),
-							webassembly: new WebAssemblyGenerator()
+							webassembly: new WebAssemblyGenerator(this.options)
 						});
 					});