webpack 4.10.1 → 4.12.0

package/lib/Parser.js

@@ -7,8 +7,8 @@
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
 
 const acorn = require("acorn-dynamic-import").default;
-const { Tapable, SyncBailHook } = require("tapable");
-const HookMap = require("tapable/lib/HookMap");
+const { Tapable, SyncBailHook, HookMap } = require("tapable");
+const util = require("util");
 const vm = require("vm");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 const StackedSetMap = require("./util/StackedSetMap");
@@ -23,7 +23,7 @@ const joinRanges = (startRange, endRange) => {
 const defaultParserOptions = {
 	ranges: true,
 	locations: true,
-	ecmaVersion: 2018,
+	ecmaVersion: 2019,
 	sourceType: "module",
 	onComment: null,
 	plugins: {
@@ -31,6 +31,16 @@ const defaultParserOptions = {
 	}
 };
 
+// regexp to match at lease one "magic comment"
+const webpackCommentRegExp = new RegExp(/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/);
+
+const EMPTY_ARRAY = [];
+
+const EMPTY_COMMENT_OPTIONS = {
+	options: null,
+	errors: null
+};
+
 class Parser extends Tapable {
 	constructor(options, sourceType = "auto") {
 		super();
@@ -117,17 +127,18 @@ class Parser extends Tapable {
 				const regexp = HOOK_MAP_COMPAT_CONFIG[name];
 				const match = regexp.exec(options.name);
 				if (match) {
-					if (match[1])
+					if (match[1]) {
 						this.hooks[name].tap(
 							match[1],
 							options.fn.name || "unnamed compat plugin",
 							options.fn.bind(this)
 						);
-					else
+					} else {
 						this.hooks[name].tap(
 							options.fn.name || "unnamed compat plugin",
 							options.fn.bind(this)
 						);
+					}
 					return true;
 				}
 			}
@@ -156,12 +167,14 @@ class Parser extends Tapable {
 						.setBoolean(expr.value)
 						.setRange(expr.range);
 			}
-			if (expr.value === null)
+			if (expr.value === null) {
 				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
-			if (expr.value instanceof RegExp)
+			}
+			if (expr.value instanceof RegExp) {
 				return new BasicEvaluatedExpression()
 					.setRegExp(expr.value)
 					.setRange(expr.range);
+			}
 		});
 		this.hooks.evaluate.for("LogicalExpression").tap("Parser", expr => {
 			let left;
@@ -411,22 +424,26 @@ class Parser extends Tapable {
 						.setRange(expr.range);
 				}
 				const arg = this.evaluateExpression(expr.argument);
-				if (arg.isString() || arg.isWrapped())
+				if (arg.isString() || arg.isWrapped()) {
 					return new BasicEvaluatedExpression()
 						.setString("string")
 						.setRange(expr.range);
-				else if (arg.isNumber())
+				}
+				if (arg.isNumber()) {
 					return new BasicEvaluatedExpression()
 						.setString("number")
 						.setRange(expr.range);
-				else if (arg.isBoolean())
+				}
+				if (arg.isBoolean()) {
 					return new BasicEvaluatedExpression()
 						.setString("boolean")
 						.setRange(expr.range);
-				else if (arg.isArray() || arg.isConstArray() || arg.isRegExp())
+				}
+				if (arg.isArray() || arg.isConstArray() || arg.isRegExp()) {
 					return new BasicEvaluatedExpression()
 						.setString("object")
 						.setRange(expr.range);
+				}
 			} else if (expr.operator === "!") {
 				const argument = this.evaluateExpression(expr.argument);
 				if (!argument) return;
@@ -434,19 +451,23 @@ class Parser extends Tapable {
 					return new BasicEvaluatedExpression()
 						.setBoolean(!argument.bool)
 						.setRange(expr.range);
-				} else if (argument.isTruthy()) {
+				}
+				if (argument.isTruthy()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(false)
 						.setRange(expr.range);
-				} else if (argument.isFalsy()) {
+				}
+				if (argument.isFalsy()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(true)
 						.setRange(expr.range);
-				} else if (argument.isString()) {
+				}
+				if (argument.isString()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(!argument.string)
 						.setRange(expr.range);
-				} else if (argument.isNumber()) {
+				}
+				if (argument.isNumber()) {
 					return new BasicEvaluatedExpression()
 						.setBoolean(!argument.number)
 						.setRange(expr.range);
@@ -696,7 +717,9 @@ class Parser extends Tapable {
 					result = param.string.split(arg.string);
 				} else if (arg.isRegExp()) {
 					result = param.string.split(arg.regExp);
-				} else return;
+				} else {
+					return;
+				}
 				return new BasicEvaluatedExpression()
 					.setArray(result)
 					.setRange(expr.range);
@@ -710,10 +733,16 @@ class Parser extends Tapable {
 				const alternate = this.evaluateExpression(expr.alternate);
 				if (!consequent || !alternate) return;
 				res = new BasicEvaluatedExpression();
-				if (consequent.isConditional()) res.setOptions(consequent.options);
-				else res.setOptions([consequent]);
-				if (alternate.isConditional()) res.addOptions(alternate.options);
-				else res.addOptions([alternate]);
+				if (consequent.isConditional()) {
+					res.setOptions(consequent.options);
+				} else {
+					res.setOptions([consequent]);
+				}
+				if (alternate.isConditional()) {
+					res.addOptions(alternate.options);
+				} else {
+					res.addOptions([alternate]);
+				}
 			} else {
 				res = this.evaluateExpression(
 					conditionValue ? expr.consequent : expr.alternate
@@ -735,9 +764,9 @@ class Parser extends Tapable {
 
 	getRenameIdentifier(expr) {
 		const result = this.evaluateExpression(expr);
-		if (!result) return;
-		if (result.isIdentifier()) return result.identifier;
-		return;
+		if (result && result.isIdentifier()) {
+			return result.identifier;
+		}
 	}
 
 	walkClass(classy) {
@@ -746,17 +775,21 @@ class Parser extends Tapable {
 			const wasTopLevel = this.scope.topLevelScope;
 			this.scope.topLevelScope = false;
 			for (const methodDefinition of classy.body.body) {
-				if (methodDefinition.type === "MethodDefinition")
+				if (methodDefinition.type === "MethodDefinition") {
 					this.walkMethodDefinition(methodDefinition);
+				}
 			}
 			this.scope.topLevelScope = wasTopLevel;
 		}
 	}
 
 	walkMethodDefinition(methodDefinition) {
-		if (methodDefinition.computed && methodDefinition.key)
+		if (methodDefinition.computed && methodDefinition.key) {
 			this.walkExpression(methodDefinition.key);
-		if (methodDefinition.value) this.walkExpression(methodDefinition.value);
+		}
+		if (methodDefinition.value) {
+			this.walkExpression(methodDefinition.value);
+		}
 	}
 
 	// Prewalking iterates the scope for variable declarations
@@ -912,7 +945,9 @@ class Parser extends Tapable {
 
 	prewalkIfStatement(statement) {
 		this.prewalkStatement(statement.consequent);
-		if (statement.alternate) this.prewalkStatement(statement.alternate);
+		if (statement.alternate) {
+			this.prewalkStatement(statement.alternate);
+		}
 	}
 
 	walkIfStatement(statement) {
@@ -920,10 +955,15 @@ class Parser extends Tapable {
 		if (result === undefined) {
 			this.walkExpression(statement.test);
 			this.walkStatement(statement.consequent);
-			if (statement.alternate) this.walkStatement(statement.alternate);
+			if (statement.alternate) {
+				this.walkStatement(statement.alternate);
+			}
 		} else {
-			if (result) this.walkStatement(statement.consequent);
-			else if (statement.alternate) this.walkStatement(statement.alternate);
+			if (result) {
+				this.walkStatement(statement.consequent);
+			} else if (statement.alternate) {
+				this.walkStatement(statement.alternate);
+			}
 		}
 	}
 
@@ -1006,26 +1046,34 @@ class Parser extends Tapable {
 
 	prewalkForStatement(statement) {
 		if (statement.init) {
-			if (statement.init.type === "VariableDeclaration")
+			if (statement.init.type === "VariableDeclaration") {
 				this.prewalkStatement(statement.init);
+			}
 		}
 		this.prewalkStatement(statement.body);
 	}
 
 	walkForStatement(statement) {
 		if (statement.init) {
-			if (statement.init.type === "VariableDeclaration")
+			if (statement.init.type === "VariableDeclaration") {
 				this.walkStatement(statement.init);
-			else this.walkExpression(statement.init);
+			} else {
+				this.walkExpression(statement.init);
+			}
+		}
+		if (statement.test) {
+			this.walkExpression(statement.test);
+		}
+		if (statement.update) {
+			this.walkExpression(statement.update);
 		}
-		if (statement.test) this.walkExpression(statement.test);
-		if (statement.update) this.walkExpression(statement.update);
 		this.walkStatement(statement.body);
 	}
 
 	prewalkForInStatement(statement) {
-		if (statement.left.type === "VariableDeclaration")
+		if (statement.left.type === "VariableDeclaration") {
 			this.prewalkVariableDeclaration(statement.left);
+		}
 		this.prewalkStatement(statement.body);
 	}
 
@@ -1142,7 +1190,7 @@ class Parser extends Tapable {
 				switch (specifier.type) {
 					case "ExportSpecifier": {
 						const name = specifier.exported.name;
-						if (source)
+						if (source) {
 							this.hooks.exportImportSpecifier.call(
 								statement,
 								source,
@@ -1150,13 +1198,14 @@ class Parser extends Tapable {
 								name,
 								specifierIndex
 							);
-						else
+						} else {
 							this.hooks.exportSpecifier.call(
 								statement,
 								specifier.local.name,
 								name,
 								specifierIndex
 							);
+						}
 						break;
 					}
 				}
@@ -1309,7 +1358,11 @@ class Parser extends Tapable {
 	}
 
 	walkCatchClause(catchClause) {
-		this.inScope([catchClause.param], () => {
+		// Error binding is optional in catch clause since ECMAScript 2019
+		const errorBinding =
+			catchClause.param === null ? EMPTY_ARRAY : [catchClause.param];
+
+		this.inScope(errorBinding, () => {
 			this.prewalkStatement(catchClause.body);
 			this.walkStatement(catchClause.body);
 		});
@@ -1445,11 +1498,15 @@ class Parser extends Tapable {
 	}
 
 	walkArrayExpression(expression) {
-		if (expression.elements) this.walkExpressions(expression.elements);
+		if (expression.elements) {
+			this.walkExpressions(expression.elements);
+		}
 	}
 
 	walkSpreadElement(expression) {
-		if (expression.argument) this.walkExpression(expression.argument);
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
 	}
 
 	walkObjectExpression(expression) {
@@ -1463,10 +1520,16 @@ class Parser extends Tapable {
 				this.walkExpression(prop.argument);
 				continue;
 			}
-			if (prop.computed) this.walkExpression(prop.key);
-			if (prop.shorthand) this.scope.inShorthand = true;
+			if (prop.computed) {
+				this.walkExpression(prop.key);
+			}
+			if (prop.shorthand) {
+				this.scope.inShorthand = true;
+			}
 			this.walkExpression(prop.value);
-			if (prop.shorthand) this.scope.inShorthand = false;
+			if (prop.shorthand) {
+				this.scope.inShorthand = false;
+			}
 		}
 	}
 
@@ -1576,10 +1639,15 @@ class Parser extends Tapable {
 		if (result === undefined) {
 			this.walkExpression(expression.test);
 			this.walkExpression(expression.consequent);
-			if (expression.alternate) this.walkExpression(expression.alternate);
+			if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
 		} else {
-			if (result) this.walkExpression(expression.consequent);
-			else if (expression.alternate) this.walkExpression(expression.alternate);
+			if (result) {
+				this.walkExpression(expression.consequent);
+			} else if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
 		}
 	}
 
@@ -1596,21 +1664,30 @@ class Parser extends Tapable {
 		}
 
 		this.walkExpression(expression.callee);
-		if (expression.arguments) this.walkExpressions(expression.arguments);
+		if (expression.arguments) {
+			this.walkExpressions(expression.arguments);
+		}
 	}
 
 	walkYieldExpression(expression) {
-		if (expression.argument) this.walkExpression(expression.argument);
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
 	}
 
 	walkTemplateLiteral(expression) {
-		if (expression.expressions) this.walkExpressions(expression.expressions);
+		if (expression.expressions) {
+			this.walkExpressions(expression.expressions);
+		}
 	}
 
 	walkTaggedTemplateExpression(expression) {
-		if (expression.tag) this.walkExpression(expression.tag);
-		if (expression.quasi && expression.quasi.expressions)
+		if (expression.tag) {
+			this.walkExpression(expression.tag);
+		}
+		if (expression.quasi && expression.quasi.expressions) {
 			this.walkExpressions(expression.quasi.expressions);
+		}
 	}
 
 	walkClassExpression(expression) {
@@ -1624,8 +1701,9 @@ class Parser extends Tapable {
 				const hook = this.hooks.canRename.get(renameIdentifier);
 				if (hook !== undefined && hook.call(argOrThis)) {
 					const hook = this.hooks.rename.get(renameIdentifier);
-					if (hook === undefined || !hook.call(argOrThis))
+					if (hook === undefined || !hook.call(argOrThis)) {
 						return renameIdentifier;
+					}
 				}
 			}
 			this.walkExpression(argOrThis);
@@ -1852,11 +1930,12 @@ class Parser extends Tapable {
 	parseString(expression) {
 		switch (expression.type) {
 			case "BinaryExpression":
-				if (expression.operator === "+")
+				if (expression.operator === "+") {
 					return (
 						this.parseString(expression.left) +
 						this.parseString(expression.right)
 					);
+				}
 				break;
 			case "Literal":
 				return expression.value + "";
@@ -1903,12 +1982,20 @@ class Parser extends Tapable {
 				const consequent = this.parseCalculatedString(expression.consequent);
 				const alternate = this.parseCalculatedString(expression.alternate);
 				const items = [];
-				if (consequent.conditional) items.push(...consequent.conditional);
-				else if (!consequent.code) items.push(consequent);
-				else break;
-				if (alternate.conditional) items.push(...alternate.conditional);
-				else if (!alternate.code) items.push(alternate);
-				else break;
+				if (consequent.conditional) {
+					items.push(...consequent.conditional);
+				} else if (!consequent.code) {
+					items.push(consequent);
+				} else {
+					break;
+				}
+				if (alternate.conditional) {
+					items.push(...alternate.conditional);
+				} else if (!alternate.code) {
+					items.push(alternate);
+				} else {
+					break;
+				}
 				return {
 					range: undefined,
 					value: "",
@@ -1975,8 +2062,9 @@ class Parser extends Tapable {
 			sourceType: this.sourceType,
 			locations: false
 		});
-		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement")
+		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
 			throw new Error("evaluate: Source is not a expression");
+		}
 		return this.evaluateExpression(ast.body[0].expression);
 	}
 
@@ -1986,20 +2074,27 @@ class Parser extends Tapable {
 		);
 	}
 
-	getCommentOptions(range) {
+	parseCommentOptions(range) {
 		const comments = this.getComments(range);
-		if (comments.length === 0) return null;
-		const options = comments.map(comment => {
-			try {
-				let val = vm.runInNewContext(
-					`(function(){return {${comment.value}};})()`
-				);
-				return val;
-			} catch (e) {
-				return {};
+		if (comments.length === 0) {
+			return EMPTY_COMMENT_OPTIONS;
+		}
+		let options = {};
+		let errors = [];
+		for (const comment of comments) {
+			const { value } = comment;
+			if (value && webpackCommentRegExp.test(value)) {
+				// try compile only if webpack options comment is present
+				try {
+					const val = vm.runInNewContext(`(function(){return {${value}};})()`);
+					Object.assign(options, val);
+				} catch (e) {
+					e.comment = comment;
+					errors.push(e);
+				}
 			}
-		});
-		return options.reduce((o, i) => Object.assign(o, i), {});
+		}
+		return { options, errors };
 	}
 
 	getNameForExpression(expression) {
@@ -2029,8 +2124,12 @@ class Parser extends Tapable {
 			return null;
 		}
 		let prefix = "";
-		for (let i = exprName.length - 1; i >= 2; i--) prefix += exprName[i] + ".";
-		if (exprName.length > 1) prefix += exprName[1];
+		for (let i = exprName.length - 1; i >= 2; i--) {
+			prefix += exprName[i] + ".";
+		}
+		if (exprName.length > 1) {
+			prefix += exprName[1];
+		}
 		const name = prefix ? prefix + "." + exprName[0] : exprName[0];
 		const nameGeneral = prefix;
 		return {
@@ -2083,4 +2182,12 @@ class Parser extends Tapable {
 	}
 }
 
+// TODO remove in webpack 5
+Object.defineProperty(Parser.prototype, "getCommentOptions", {
+	configurable: false,
+	value: util.deprecate(function(range) {
+		return this.parseCommentOptions(range).options;
+	}, "Parser.getCommentOptions: Use Parser.parseCommentOptions(range) instead")
+});
+
 module.exports = Parser;

package/lib/ParserHelpers.js

@@ -72,8 +72,11 @@ ParserHelpers.evaluateToIdentifier = (identifier, truthy) => {
 		let evex = new BasicEvaluatedExpression()
 			.setIdentifier(identifier)
 			.setRange(expr.range);
-		if (truthy === true) evex = evex.setTruthy();
-		else if (truthy === false) evex = evex.setFalsy();
+		if (truthy === true) {
+			evex = evex.setTruthy();
+		} else if (truthy === false) {
+			evex = evex.setFalsy();
+		}
 		return evex;
 	};
 };
@@ -85,7 +88,7 @@ ParserHelpers.expressionIsUnsupported = (parser, message) => {
 		parser.state.current.addDependency(dep);
 		if (!parser.state.module) return;
 		parser.state.module.warnings.push(
-			new UnsupportedFeatureWarning(parser.state.module, message)
+			new UnsupportedFeatureWarning(parser.state.module, message, expr.loc)
 		);
 		return true;
 	};

package/lib/ProgressPlugin.js

@@ -101,7 +101,7 @@ class ProgressPlugin {
 
 			const update = module => {
 				handler(
-					0.1 + doneModules / Math.max(lastModulesCount, moduleCount) * 0.6,
+					0.1 + (doneModules / Math.max(lastModulesCount, moduleCount)) * 0.6,
 					"building modules",
 					`${doneModules}/${moduleCount} modules`,
 					`${activeModules.length} active`,
@@ -187,7 +187,7 @@ class ProgressPlugin {
 				const numberOfHooks = Object.keys(hooks).length;
 				Object.keys(hooks).forEach((name, idx) => {
 					const title = hooks[name];
-					const percentage = idx / numberOfHooks * 0.25 + 0.7;
+					const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
 					compilation.hooks[name].intercept({
 						name: "ProgressPlugin",
 						context: true,
@@ -222,6 +222,21 @@ class ProgressPlugin {
 					handler(0.95, "emitting", tap.name);
 				}
 			});
+			compiler.hooks.afterEmit.intercept({
+				name: "ProgressPlugin",
+				context: true,
+				call: () => {
+					handler(0.98, "after emitting");
+				},
+				tap: (context, tap) => {
+					if (context) {
+						context.reportProgress = (p, ...args) => {
+							handler(0.98, "after emitting", tap.name, ...args);
+						};
+					}
+					handler(0.98, "after emitting", tap.name);
+				}
+			});
 			compiler.hooks.done.tap("ProgressPlugin", () => {
 				handler(1, "");
 			});

package/lib/RawModule.js

@@ -42,9 +42,11 @@ module.exports = class RawModule extends Module {
 	}
 
 	source() {
-		if (this.useSourceMap)
+		if (this.useSourceMap) {
 			return new OriginalSource(this.sourceStr, this.identifier());
-		else return new RawSource(this.sourceStr);
+		} else {
+			return new RawSource(this.sourceStr);
+		}
 	}
 
 	updateHash(hash) {