Merge branch 'master' into feature/module-build-error-with-loader-name

# Conflicts:
#	lib/ModuleBuildError.js
#	lib/ModuleError.js
#	lib/ModuleWarning.js

Author: sokra

declarations.d.ts

@@ -36,6 +36,7 @@ declare module "@webassemblyjs/ast" {
 			ModuleImport?: (p: NodePath<ModuleImport>) => void;
 			ModuleExport?: (p: NodePath<ModuleExport>) => void;
 			Start?: (p: NodePath<Start>) => void;
+			Global?: (p: NodePath<Global>) => void;
 		}
 	);
 	export class NodePath<T> {
@@ -60,28 +61,46 @@ declare module "@webassemblyjs/ast" {
 	}
 	export class ModuleExport extends Node {
 		name: string;
+		descr: ModuleExportDescr;
+	}
+	type Index = Identifier | NumberLiteral;
+	export class ModuleExportDescr extends Node {
+		type: string;
+		exportType: string;
+		id: Index;
+	}
+	export class NumberLiteral extends Node {
+		value: number;
+		raw: string;
 	}
-	export class ModuleExportDescr extends Node {}
-	export class IndexLiteral extends Node {}
-	export class NumberLiteral extends Node {}
 	export class FloatLiteral extends Node {}
-	export class Global extends Node {}
+	export class GlobalType extends Node {
+		valtype: string;
+	}
+	export class Global extends Node {
+		init: Instruction[];
+		globalType: GlobalType;
+	}
 	export class FuncParam extends Node {
 		valtype: string;
 	}
-	export class Instruction extends Node {}
+	export class Instruction extends Node {
+		id: string;
+		args: NumberLiteral[];
+	}
 	export class CallInstruction extends Instruction {}
 	export class ObjectInstruction extends Instruction {}
 	export class Func extends Node {
 		signature: Signature;
 	}
 	export class Signature {
+		type: "Signature";
 		params: FuncParam[];
 		results: string[];
 	}
 	export class TypeInstruction extends Node {}
 	export class IndexInFuncSection extends Node {}
-	export function indexLiteral(index: number): IndexLiteral;
+	export function indexLiteral(index: number): Index;
 	export function numberLiteralFromRaw(num: number): NumberLiteral;
 	export function floatLiteral(
 		value: number,
@@ -93,29 +112,33 @@ declare module "@webassemblyjs/ast" {
 	export function identifier(indentifier: string): Identifier;
 	export function funcParam(valType: string, id: Identifier): FuncParam;
 	export function instruction(inst: string, args: Node[]): Instruction;
-	export function callInstruction(funcIndex: IndexLiteral): CallInstruction;
+	export function callInstruction(funcIndex: Index): CallInstruction;
 	export function objectInstruction(
 		kind: string,
 		type: string,
 		init: Node[]
 	): ObjectInstruction;
 	export function signature(params: FuncParam[], results: string[]): Signature;
-	export function func(initFuncId, Signature, funcBody): Func;
+	export function func(initFuncId, signature: Signature, funcBody): Func;
 	export function typeInstruction(
 		id: Identifier,
 		functype: Signature
 	): TypeInstruction;
-	export function indexInFuncSection(index: IndexLiteral): IndexInFuncSection;
+	export function indexInFuncSection(index: Index): IndexInFuncSection;
 	export function moduleExport(
 		identifier: string,
 		descr: ModuleExportDescr
 	): ModuleExport;
 	export function moduleExportDescr(
 		type: string,
-		index: ModuleExportDescr
-	): ModuleExport;
+		index: Index
+	): ModuleExportDescr;
 
 	export function getSectionMetadata(ast: any, section: string);
+	export class FuncSignature {
+		args: string[];
+		result: string[];
+	}
 }
 
 /**

lib/AsyncDependencyToInitialChunkError.js

@@ -16,13 +16,13 @@ class AsyncDependencyToInitialChunkError extends WebpackError {
 	 * @param {TODO} loc location of dependency
 	 */
 	constructor(chunkName, module, loc) {
-		super();
+		super(
+			`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`
+		);
 
 		this.name = "AsyncDependencyToInitialChunkError";
-		this.message = `It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`;
 		this.module = module;
-		this.origin = module;
-		this.originLoc = loc;
+		this.loc = loc;
 
 		Error.captureStackTrace(this, this.constructor);
 	}

lib/CaseSensitiveModulesWarning.js

@@ -8,64 +8,60 @@ const WebpackError = require("./WebpackError");
 
 /** @typedef {import("./Module")} Module */
 
+/**
+ * @param {Module[]} modules the modules to be sorted
+ * @returns {Module[]} sorted version of original modules
+ */
+const sortModules = modules => {
+	return modules.slice().sort((a, b) => {
+		a = a.identifier();
+		b = b.identifier();
+		/* istanbul ignore next */
+		if (a < b) return -1;
+		/* istanbul ignore next */
+		if (a > b) return 1;
+		/* istanbul ignore next */
+		return 0;
+	});
+};
+
+/**
+ * @param {Module[]} modules each module from throw
+ * @returns {string} each message from provided moduels
+ */
+const createModulesListMessage = modules => {
+	return modules
+		.map(m => {
+			let message = `* ${m.identifier()}`;
+			const validReasons = m.reasons.filter(reason => reason.module);
+
+			if (validReasons.length > 0) {
+				message += `\n    Used by ${validReasons.length} module(s), i. e.`;
+				message += `\n    ${validReasons[0].module.identifier()}`;
+			}
+			return message;
+		})
+		.join("\n");
+};
+
 class CaseSensitiveModulesWarning extends WebpackError {
 	/**
 	 * Creates an instance of CaseSensitiveModulesWarning.
 	 * @param {Module[]} modules modules that were detected
 	 */
 	constructor(modules) {
-		super();
-
-		this.name = "CaseSensitiveModulesWarning";
-		const sortedModules = this._sort(modules);
-		const modulesList = this._moduleMessages(sortedModules);
-		this.message = `There are multiple modules with names that only differ in casing.
+		const sortedModules = sortModules(modules);
+		const modulesList = createModulesListMessage(sortedModules);
+		super(`There are multiple modules with names that only differ in casing.
 This can lead to unexpected behavior when compiling on a filesystem with other case-semantic.
 Use equal casing. Compare these module identifiers:
-${modulesList}`;
+${modulesList}`);
 
+		this.name = "CaseSensitiveModulesWarning";
 		this.origin = this.module = sortedModules[0];
 
 		Error.captureStackTrace(this, this.constructor);
 	}
-
-	/**
-	 * @private
-	 * @param {Module[]} modules the modules to be sorted
-	 * @returns {Module[]} sorted version of original modules
-	 */
-	_sort(modules) {
-		return modules.slice().sort((a, b) => {
-			a = a.identifier();
-			b = b.identifier();
-			/* istanbul ignore next */
-			if (a < b) return -1;
-			/* istanbul ignore next */
-			if (a > b) return 1;
-			/* istanbul ignore next */
-			return 0;
-		});
-	}
-
-	/**
-	 * @private
-	 * @param {Module[]} modules each module from throw
-	 * @returns {string} each message from provided moduels
-	 */
-	_moduleMessages(modules) {
-		return modules
-			.map(m => {
-				let message = `* ${m.identifier()}`;
-				const validReasons = m.reasons.filter(reason => reason.module);
-
-				if (validReasons.length > 0) {
-					message += `\n    Used by ${validReasons.length} module(s), i. e.`;
-					message += `\n    ${validReasons[0].module.identifier()}`;
-				}
-				return message;
-			})
-			.join("\n");
-	}
 }
 
 module.exports = CaseSensitiveModulesWarning;

lib/Chunk.js

@@ -607,10 +607,10 @@ class Chunk {
 		return result;
 	}
 
-	getChildIdsByOrdersMap() {
+	getChildIdsByOrdersMap(includeDirectChildren) {
 		const chunkMaps = Object.create(null);
 
-		for (const chunk of this.getAllAsyncChunks()) {
+		const addChildIdsByOrdersToMap = chunk => {
 			const data = chunk.getChildIdsByOrders();
 			for (const key of Object.keys(data)) {
 				let chunkMap = chunkMaps[key];
@@ -619,7 +619,16 @@ class Chunk {
 				}
 				chunkMap[chunk.id] = data[key];
 			}
+		};
+
+		if (includeDirectChildren) {
+			addChildIdsByOrdersToMap(this);
 		}
+
+		for (const chunk of this.getAllAsyncChunks()) {
+			addChildIdsByOrdersToMap(chunk);
+		}
+
 		return chunkMaps;
 	}
 

lib/CommentCompilationWarning.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class CommentCompilationWarning extends WebpackError {
+	constructor(message, module, loc) {
+		super(message);
+
+		this.name = "CommentCompilationWarning";
+
+		this.module = module;
+		this.loc = loc;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+module.exports = CommentCompilationWarning;

lib/Compilation.js

@@ -487,6 +487,7 @@ class Compilation extends Tapable {
 
 				const errorAndCallback = err => {
 					err.origin = module;
+					err.dependencies = dependencies;
 					this.errors.push(err);
 					if (bail) {
 						callback(err);
@@ -531,7 +532,7 @@ class Compilation extends Tapable {
 							if (err) {
 								semaphore.release();
 								return errorOrWarningAndCallback(
-									new ModuleNotFoundError(module, err, dependencies)
+									new ModuleNotFoundError(module, err)
 								);
 							}
 							if (!dependentModule) {

lib/EntryModuleNotFoundError.js

@@ -8,10 +8,9 @@ const WebpackError = require("./WebpackError");
 
 class EntryModuleNotFoundError extends WebpackError {
 	constructor(err) {
-		super();
+		super("Entry module not found: " + err);
 
 		this.name = "EntryModuleNotFoundError";
-		this.message = "Entry module not found: " + err;
 		this.details = err.details;
 		this.error = err;
 

lib/HarmonyLinkingError.js

@@ -8,9 +8,8 @@ const WebpackError = require("./WebpackError");
 module.exports = class HarmonyLinkingError extends WebpackError {
 	/** @param {string} message Error message */
 	constructor(message) {
-		super();
+		super(message);
 		this.name = "HarmonyLinkingError";
-		this.message = message;
 		this.hideStack = true;
 
 		Error.captureStackTrace(this, this.constructor);

lib/ModuleBuildError.js

@@ -9,41 +9,38 @@ const { cutOffLoaderExecution } = require("./ErrorHelpers");
 
 class ModuleBuildError extends WebpackError {
 	constructor(module, err, { from = null } = {}) {
-		super();
-
-		this.name = "ModuleBuildError";
-		this.message = "Module build failed";
+		let message = "Module build failed";
+		let details = undefined;
 		if (from) {
-			this.message += ` (from ${from})`;
+			message += ` (from ${from})`;
 		}
-
-		let message;
+		message += ": ";
 		if (err !== null && typeof err === "object") {
 			if (typeof err.stack === "string" && err.stack) {
 				const stack = cutOffLoaderExecution(err.stack);
 				if (!err.hideStack) {
-					message = stack;
+					message += stack;
 				} else {
-					this.details = stack;
+					details = stack;
 					if (typeof err.message === "string" && err.message) {
-						message = err.message;
+						message += err.message;
 					} else {
-						message = err;
+						message += err;
 					}
 				}
 			} else if (typeof err.message === "string" && err.message) {
-				message = err.message;
+				message += err.message;
 			} else {
-				message = err;
+				message += err;
 			}
 		} else {
 			message = err;
 		}
 
-		if (message !== "") {
-			this.message += `:\n${message}`;
-		}
+		super(message);
 
+		this.name = "ModuleBuildError";
+		this.details = details;
 		this.module = module;
 		this.error = err;