webpack 3.5.1 → 3.5.5

package/lib/Compilation.js

@@ -22,6 +22,7 @@ const Dependency = require("./Dependency");
 const ChunkRenderError = require("./ChunkRenderError");
 const CachedSource = require("webpack-sources").CachedSource;
 const Stats = require("./Stats");
+const Semaphore = require("./util/Semaphore");
 
 function byId(a, b) {
 	if(a.id < b.id) return -1;
@@ -62,6 +63,8 @@ class Compilation extends Tapable {
 		this.hotUpdateChunkTemplate = new HotUpdateChunkTemplate(this.outputOptions);
 		this.moduleTemplate = new ModuleTemplate(this.outputOptions);
 
+		this.semaphore = new Semaphore(options.parallelism || 100);
+
 		this.entries = [];
 		this.preparedChunks = [];
 		this.entrypoints = {};
@@ -229,120 +232,128 @@ class Compilation extends Tapable {
 				callback();
 			};
 
-			const factory = item[0];
-			factory.create({
-				contextInfo: {
-					issuer: module.nameForCondition && module.nameForCondition(),
-					compiler: _this.compiler.name
-				},
-				context: module.context,
-				dependencies: dependencies
-			}, function factoryCallback(err, dependentModule) {
-				let afterFactory;
-
-				function isOptional() {
-					return dependencies.filter(d => !d.optional).length === 0;
-				}
+			_this.semaphore.acquire(() => {
+				const factory = item[0];
+				factory.create({
+					contextInfo: {
+						issuer: module.nameForCondition && module.nameForCondition(),
+						compiler: _this.compiler.name
+					},
+					context: module.context,
+					dependencies: dependencies
+				}, function factoryCallback(err, dependentModule) {
+					let afterFactory;
+
+					function isOptional() {
+						return dependencies.filter(d => !d.optional).length === 0;
+					}
 
-				function errorOrWarningAndCallback(err) {
-					if(isOptional()) {
-						return warningAndCallback(err);
-					} else {
-						return errorAndCallback(err);
+					function errorOrWarningAndCallback(err) {
+						if(isOptional()) {
+							return warningAndCallback(err);
+						} else {
+							return errorAndCallback(err);
+						}
 					}
-				}
 
-				function iterationDependencies(depend) {
-					for(let index = 0; index < depend.length; index++) {
-						const dep = depend[index];
-						dep.module = dependentModule;
-						dependentModule.addReason(module, dep);
+					function iterationDependencies(depend) {
+						for(let index = 0; index < depend.length; index++) {
+							const dep = depend[index];
+							dep.module = dependentModule;
+							dependentModule.addReason(module, dep);
+						}
 					}
-				}
 
-				if(err) {
-					return errorOrWarningAndCallback(new ModuleNotFoundError(module, err, dependencies));
-				}
-				if(!dependentModule) {
-					return process.nextTick(callback);
-				}
-				if(_this.profile) {
-					if(!dependentModule.profile) {
-						dependentModule.profile = {};
+					if(err) {
+						_this.semaphore.release();
+						return errorOrWarningAndCallback(new ModuleNotFoundError(module, err, dependencies));
+					}
+					if(!dependentModule) {
+						_this.semaphore.release();
+						return process.nextTick(callback);
+					}
+					if(_this.profile) {
+						if(!dependentModule.profile) {
+							dependentModule.profile = {};
+						}
+						afterFactory = Date.now();
+						dependentModule.profile.factory = afterFactory - start;
 					}
-					afterFactory = Date.now();
-					dependentModule.profile.factory = afterFactory - start;
-				}
 
-				dependentModule.issuer = module;
-				const newModule = _this.addModule(dependentModule, cacheGroup);
+					dependentModule.issuer = module;
+					const newModule = _this.addModule(dependentModule, cacheGroup);
 
-				if(!newModule) { // from cache
-					dependentModule = _this.getModule(dependentModule);
+					if(!newModule) { // from cache
+						dependentModule = _this.getModule(dependentModule);
 
-					if(dependentModule.optional) {
-						dependentModule.optional = isOptional();
-					}
+						if(dependentModule.optional) {
+							dependentModule.optional = isOptional();
+						}
 
-					iterationDependencies(dependencies);
+						iterationDependencies(dependencies);
 
-					if(_this.profile) {
-						if(!module.profile) {
-							module.profile = {};
-						}
-						const time = Date.now() - start;
-						if(!module.profile.dependencies || time > module.profile.dependencies) {
-							module.profile.dependencies = time;
+						if(_this.profile) {
+							if(!module.profile) {
+								module.profile = {};
+							}
+							const time = Date.now() - start;
+							if(!module.profile.dependencies || time > module.profile.dependencies) {
+								module.profile.dependencies = time;
+							}
 						}
+
+						_this.semaphore.release();
+						return process.nextTick(callback);
 					}
 
-					return process.nextTick(callback);
-				}
+					if(newModule instanceof Module) {
+						if(_this.profile) {
+							newModule.profile = dependentModule.profile;
+						}
 
-				if(newModule instanceof Module) {
-					if(_this.profile) {
-						newModule.profile = dependentModule.profile;
-					}
+						newModule.optional = isOptional();
+						newModule.issuer = dependentModule.issuer;
+						dependentModule = newModule;
 
-					newModule.optional = isOptional();
-					newModule.issuer = dependentModule.issuer;
-					dependentModule = newModule;
+						iterationDependencies(dependencies);
 
-					iterationDependencies(dependencies);
+						if(_this.profile) {
+							const afterBuilding = Date.now();
+							module.profile.building = afterBuilding - afterFactory;
+						}
 
-					if(_this.profile) {
-						const afterBuilding = Date.now();
-						module.profile.building = afterBuilding - afterFactory;
+						_this.semaphore.release();
+						if(recursive) {
+							return process.nextTick(_this.processModuleDependencies.bind(_this, dependentModule, callback));
+						} else {
+							return process.nextTick(callback);
+						}
 					}
 
-					if(recursive) {
-						return process.nextTick(_this.processModuleDependencies.bind(_this, dependentModule, callback));
-					} else {
-						return process.nextTick(callback);
-					}
-				}
+					dependentModule.optional = isOptional();
 
-				dependentModule.optional = isOptional();
+					iterationDependencies(dependencies);
 
-				iterationDependencies(dependencies);
+					_this.buildModule(dependentModule, isOptional(), module, dependencies, err => {
+						if(err) {
+							_this.semaphore.release();
+							return errorOrWarningAndCallback(err);
+						}
 
-				_this.buildModule(dependentModule, isOptional(), module, dependencies, err => {
-					if(err) {
-						return errorOrWarningAndCallback(err);
-					}
+						if(_this.profile) {
+							const afterBuilding = Date.now();
+							dependentModule.profile.building = afterBuilding - afterFactory;
+						}
 
-					if(_this.profile) {
-						const afterBuilding = Date.now();
-						dependentModule.profile.building = afterBuilding - afterFactory;
-					}
+						_this.semaphore.release();
+						if(recursive) {
+							_this.processModuleDependencies(dependentModule, callback);
+						} else {
+							return callback();
+						}
+					});
 
-					if(recursive) {
-						_this.processModuleDependencies(dependentModule, callback);
-					} else {
-						return callback();
-					}
 				});
-
 			});
 		}, function finalCallbackAddModuleDependencies(err) {
 			// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
@@ -362,13 +373,13 @@ class Compilation extends Tapable {
 	_addModuleChain(context, dependency, onModule, callback) {
 		const start = this.profile && Date.now();
 
-		const errorAndCallback = this.bail ? function errorAndCallback(err) {
+		const errorAndCallback = this.bail ? (err) => {
 			callback(err);
-		} : function errorAndCallback(err) {
+		} : (err) => {
 			err.dependencies = [dependency];
 			this.errors.push(err);
 			callback();
-		}.bind(this);
+		};
 
 		if(typeof dependency !== "object" || dependency === null || !dependency.constructor) {
 			throw new Error("Parameter 'dependency' must be a Dependency");
@@ -379,79 +390,85 @@ class Compilation extends Tapable {
 			throw new Error(`No dependency factory available for this dependency type: ${dependency.constructor.name}`);
 		}
 
-		moduleFactory.create({
-			contextInfo: {
-				issuer: "",
-				compiler: this.compiler.name
-			},
-			context: context,
-			dependencies: [dependency]
-		}, (err, module) => {
-			if(err) {
-				return errorAndCallback(new EntryModuleNotFoundError(err));
-			}
-
-			let afterFactory;
-
-			if(this.profile) {
-				if(!module.profile) {
-					module.profile = {};
+		this.semaphore.acquire(() => {
+			moduleFactory.create({
+				contextInfo: {
+					issuer: "",
+					compiler: this.compiler.name
+				},
+				context: context,
+				dependencies: [dependency]
+			}, (err, module) => {
+				if(err) {
+					this.semaphore.release();
+					return errorAndCallback(new EntryModuleNotFoundError(err));
 				}
-				afterFactory = Date.now();
-				module.profile.factory = afterFactory - start;
-			}
-
-			const result = this.addModule(module);
-			if(!result) {
-				module = this.getModule(module);
 
-				onModule(module);
+				let afterFactory;
 
 				if(this.profile) {
-					const afterBuilding = Date.now();
-					module.profile.building = afterBuilding - afterFactory;
+					if(!module.profile) {
+						module.profile = {};
+					}
+					afterFactory = Date.now();
+					module.profile.factory = afterFactory - start;
 				}
 
-				return callback(null, module);
-			}
+				const result = this.addModule(module);
+				if(!result) {
+					module = this.getModule(module);
 
-			if(result instanceof Module) {
-				if(this.profile) {
-					result.profile = module.profile;
-				}
+					onModule(module);
 
-				module = result;
+					if(this.profile) {
+						const afterBuilding = Date.now();
+						module.profile.building = afterBuilding - afterFactory;
+					}
 
-				onModule(module);
+					this.semaphore.release();
+					return callback(null, module);
+				}
 
-				moduleReady.call(this);
-				return;
-			}
+				if(result instanceof Module) {
+					if(this.profile) {
+						result.profile = module.profile;
+					}
 
-			onModule(module);
+					module = result;
 
-			this.buildModule(module, false, null, null, (err) => {
-				if(err) {
-					return errorAndCallback(err);
-				}
+					onModule(module);
 
-				if(this.profile) {
-					const afterBuilding = Date.now();
-					module.profile.building = afterBuilding - afterFactory;
+					moduleReady.call(this);
+					return;
 				}
 
-				moduleReady.call(this);
-			});
+				onModule(module);
 
-			function moduleReady() {
-				this.processModuleDependencies(module, err => {
+				this.buildModule(module, false, null, null, (err) => {
 					if(err) {
-						return callback(err);
+						this.semaphore.release();
+						return errorAndCallback(err);
 					}
 
-					return callback(null, module);
+					if(this.profile) {
+						const afterBuilding = Date.now();
+						module.profile.building = afterBuilding - afterFactory;
+					}
+
+					moduleReady.call(this);
 				});
-			}
+
+				function moduleReady() {
+					this.semaphore.release();
+					this.processModuleDependencies(module, err => {
+						if(err) {
+							return callback(err);
+						}
+
+						return callback(null, module);
+					});
+				}
+			});
 		});
 	}
 
@@ -1103,6 +1120,17 @@ class Compilation extends Tapable {
 		for(let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
 			chunks[indexChunk].sortItems();
 		}
+
+		const byMessage = (a, b) => {
+			const ma = `${a.message}`;
+			const mb = `${b.message}`;
+			if(ma < mb) return -1;
+			if(mb < ma) return 1;
+			return 0;
+		};
+
+		this.errors.sort(byMessage);
+		this.warnings.sort(byMessage);
 	}
 
 	summarizeDependencies() {
@@ -1171,6 +1199,12 @@ class Compilation extends Tapable {
 		this.children.forEach(function(child) {
 			hash.update(child.hash);
 		});
+		this.warnings.forEach(function(warning) {
+			hash.update(`${warning.message}`);
+		});
+		this.errors.forEach(function(error) {
+			hash.update(`${error.message}`);
+		});
 		// clone needed as sort below is inplace mutation
 		const chunks = this.chunks.slice();
 		/**

package/lib/Compiler.js

@@ -201,7 +201,7 @@ class Compiler extends Tapable {
 					});
 				});
 			},
-			apply: function() {
+			apply: () => {
 				const args = arguments;
 				if(!deprecationReported) {
 					console.warn("webpack: Using compiler.parser is deprecated.\n" +
@@ -214,7 +214,7 @@ class Compiler extends Tapable {
 						parser.apply.apply(parser, args);
 					});
 				});
-			}.bind(this)
+			}
 		};
 
 		this.options = {};
@@ -313,13 +313,7 @@ class Compiler extends Tapable {
 	emitAssets(compilation, callback) {
 		let outputPath;
 
-		this.applyPluginsAsync("emit", compilation, err => {
-			if(err) return callback(err);
-			outputPath = compilation.getPath(this.outputPath);
-			this.outputFileSystem.mkdirp(outputPath, emitFiles.bind(this));
-		});
-
-		function emitFiles(err) {
+		const emitFiles = (err) => {
 			if(err) return callback(err);
 
 			require("async").forEach(Object.keys(compilation.assets), (file, callback) => {
@@ -330,12 +324,7 @@ class Compiler extends Tapable {
 					targetFile = targetFile.substr(0, queryStringIdx);
 				}
 
-				if(targetFile.match(/\/|\\/)) {
-					const dir = path.dirname(targetFile);
-					this.outputFileSystem.mkdirp(this.outputFileSystem.join(outputPath, dir), writeOut.bind(this));
-				} else writeOut.call(this);
-
-				function writeOut(err) {
+				const writeOut = (err) => {
 					if(err) return callback(err);
 					const targetPath = this.outputFileSystem.join(outputPath, targetFile);
 					const source = compilation.assets[file];
@@ -352,14 +341,25 @@ class Compiler extends Tapable {
 					source.existsAt = targetPath;
 					source.emitted = true;
 					this.outputFileSystem.writeFile(targetPath, content, callback);
-				}
+				};
+
+				if(targetFile.match(/\/|\\/)) {
+					const dir = path.dirname(targetFile);
+					this.outputFileSystem.mkdirp(this.outputFileSystem.join(outputPath, dir), writeOut);
+				} else writeOut();
 
 			}, err => {
 				if(err) return callback(err);
 
 				afterEmit.call(this);
 			});
-		}
+		};
+
+		this.applyPluginsAsync("emit", compilation, err => {
+			if(err) return callback(err);
+			outputPath = compilation.getPath(this.outputPath);
+			this.outputFileSystem.mkdirp(outputPath, emitFiles);
+		});
 
 		function afterEmit() {
 			this.applyPluginsAsyncSeries1("after-emit", compilation, err => {

package/lib/ContextModuleFactory.js

@@ -103,16 +103,16 @@ module.exports = class ContextModuleFactory extends Tapable {
 		if(!regExp || !resource)
 			return callback(null, []);
 		(function addDirectory(directory, callback) {
-			fs.readdir(directory, function(err, files) {
+			fs.readdir(directory, (err, files) => {
 				if(err) return callback(err);
 				if(!files || files.length === 0) return callback(null, []);
 				asyncLib.map(files.filter(function(p) {
 					return p.indexOf(".") !== 0;
-				}), function(seqment, callback) {
+				}), (seqment, callback) => {
 
 					const subResource = path.join(directory, seqment);
 
-					fs.stat(subResource, function(err, stat) {
+					fs.stat(subResource, (err, stat) => {
 						if(err) return callback(err);
 
 						if(stat.isDirectory()) {
@@ -141,9 +141,9 @@ module.exports = class ContextModuleFactory extends Tapable {
 
 						} else callback();
 
-					}.bind(this));
+					});
 
-				}.bind(this), (err, result) => {
+				}, (err, result) => {
 					if(err) return callback(err);
 
 					if(!result) return callback(null, []);
@@ -154,7 +154,7 @@ module.exports = class ContextModuleFactory extends Tapable {
 						return a.concat(i);
 					}, []));
 				});
-			}.bind(this));
+			});
 		}.call(this, resource, callback));
 	}
 };

package/lib/EntryOptionPlugin.js

@@ -1,27 +1,27 @@
 /*
 	MIT License http://www.opensource.org/licenses/mit-license.php
 	Author Tobias Koppers @sokra
-	*/
+*/
 "use strict";
 
 const SingleEntryPlugin = require("./SingleEntryPlugin");
 const MultiEntryPlugin = require("./MultiEntryPlugin");
 const DynamicEntryPlugin = require("./DynamicEntryPlugin");
 
+function itemToPlugin(context, item, name) {
+	if(Array.isArray(item)) {
+		return new MultiEntryPlugin(context, item, name);
+	}
+	return new SingleEntryPlugin(context, item, name);
+}
+
 module.exports = class EntryOptionPlugin {
 	apply(compiler) {
 		compiler.plugin("entry-option", (context, entry) => {
-			function itemToPlugin(item, name) {
-				if(Array.isArray(item)) {
-					return new MultiEntryPlugin(context, item, name);
-				} else {
-					return new SingleEntryPlugin(context, item, name);
-				}
-			}
 			if(typeof entry === "string" || Array.isArray(entry)) {
-				compiler.apply(itemToPlugin(entry, "main"));
+				compiler.apply(itemToPlugin(context, entry, "main"));
 			} else if(typeof entry === "object") {
-				Object.keys(entry).forEach(name => compiler.apply(itemToPlugin(entry[name], name)));
+				Object.keys(entry).forEach(name => compiler.apply(itemToPlugin(context, entry[name], name)));
 			} else if(typeof entry === "function") {
 				compiler.apply(new DynamicEntryPlugin(context, entry));
 			}

package/lib/HotModuleReplacement.runtime.js

@@ -462,6 +462,9 @@ module.exports = function() {
 			// remove module from cache
 			delete installedModules[moduleId];
 
+			// when disposing there is no need to call dispose handler
+			delete outdatedDependencies[moduleId];
+
 			// remove "parents" references from all children
 			for(j = 0; j < module.children.length; j++) {
 				var child = installedModules[module.children[j]];
@@ -507,30 +510,34 @@ module.exports = function() {
 		for(moduleId in outdatedDependencies) {
 			if(Object.prototype.hasOwnProperty.call(outdatedDependencies, moduleId)) {
 				module = installedModules[moduleId];
-				moduleOutdatedDependencies = outdatedDependencies[moduleId];
-				var callbacks = [];
-				for(i = 0; i < moduleOutdatedDependencies.length; i++) {
-					dependency = moduleOutdatedDependencies[i];
-					cb = module.hot._acceptedDependencies[dependency];
-					if(callbacks.indexOf(cb) >= 0) continue;
-					callbacks.push(cb);
-				}
-				for(i = 0; i < callbacks.length; i++) {
-					cb = callbacks[i];
-					try {
-						cb(moduleOutdatedDependencies);
-					} catch(err) {
-						if(options.onErrored) {
-							options.onErrored({
-								type: "accept-errored",
-								moduleId: moduleId,
-								dependencyId: moduleOutdatedDependencies[i],
-								error: err
-							});
+				if(module) {
+					moduleOutdatedDependencies = outdatedDependencies[moduleId];
+					var callbacks = [];
+					for(i = 0; i < moduleOutdatedDependencies.length; i++) {
+						dependency = moduleOutdatedDependencies[i];
+						cb = module.hot._acceptedDependencies[dependency];
+						if(cb) {
+							if(callbacks.indexOf(cb) >= 0) continue;
+							callbacks.push(cb);
 						}
-						if(!options.ignoreErrored) {
-							if(!error)
-								error = err;
+					}
+					for(i = 0; i < callbacks.length; i++) {
+						cb = callbacks[i];
+						try {
+							cb(moduleOutdatedDependencies);
+						} catch(err) {
+							if(options.onErrored) {
+								options.onErrored({
+									type: "accept-errored",
+									moduleId: moduleId,
+									dependencyId: moduleOutdatedDependencies[i],
+									error: err
+								});
+							}
+							if(!options.ignoreErrored) {
+								if(!error)
+									error = err;
+							}
 						}
 					}
 				}

package/lib/Module.js

@@ -73,6 +73,7 @@ class Module extends DependenciesBlock {
 
 	setChunks(chunks) {
 		this._chunks = new SortableSet(chunks, sortById);
+		this._chunksDebugIdent = undefined;
 	}
 
 	addChunk(chunk) {

package/lib/Parser.js

@@ -634,14 +634,14 @@ class Parser extends Tapable {
 		statement.params.forEach(param => {
 			this.walkPattern(param);
 		});
-		this.inScope(statement.params, function() {
+		this.inScope(statement.params, () => {
 			if(statement.body.type === "BlockStatement") {
 				this.prewalkStatement(statement.body);
 				this.walkStatement(statement.body);
 			} else {
 				this.walkExpression(statement.body);
 			}
-		}.bind(this));
+		});
 	}
 
 	prewalkImportDeclaration(statement) {
@@ -784,10 +784,10 @@ class Parser extends Tapable {
 	}
 
 	walkCatchClause(catchClause) {
-		this.inScope([catchClause.param], function() {
+		this.inScope([catchClause.param], () => {
 			this.prewalkStatement(catchClause.body);
 			this.walkStatement(catchClause.body);
-		}.bind(this));
+		});
 	}
 
 	prewalkVariableDeclarators(declarators) {
@@ -916,28 +916,28 @@ class Parser extends Tapable {
 		expression.params.forEach(param => {
 			this.walkPattern(param);
 		});
-		this.inScope(expression.params, function() {
+		this.inScope(expression.params, () => {
 			if(expression.body.type === "BlockStatement") {
 				this.prewalkStatement(expression.body);
 				this.walkStatement(expression.body);
 			} else {
 				this.walkExpression(expression.body);
 			}
-		}.bind(this));
+		});
 	}
 
 	walkArrowFunctionExpression(expression) {
 		expression.params.forEach(param => {
 			this.walkPattern(param);
 		});
-		this.inScope(expression.params, function() {
+		this.inScope(expression.params, () => {
 			if(expression.body.type === "BlockStatement") {
 				this.prewalkStatement(expression.body);
 				this.walkStatement(expression.body);
 			} else {
 				this.walkExpression(expression.body);
 			}
-		}.bind(this));
+		});
 	}
 
 	walkSequenceExpression(expression) {
@@ -1059,7 +1059,7 @@ class Parser extends Tapable {
 			const args = options.map(renameArgOrThis, this);
 			this.inScope(params.filter(function(identifier, idx) {
 				return !args[idx];
-			}), function() {
+			}), () => {
 				if(renameThis) {
 					this.scope.renames.$this = renameThis;
 				}
@@ -1074,7 +1074,7 @@ class Parser extends Tapable {
 					this.walkStatement(functionExpression.body);
 				} else
 					this.walkExpression(functionExpression.body);
-			}.bind(this));
+			});
 		}
 		if(expression.callee.type === "MemberExpression" &&
 			expression.callee.object.type === "FunctionExpression" &&

package/lib/UmdMainTemplatePlugin.js

@@ -41,7 +41,7 @@ class UmdMainTemplatePlugin {
 
 	apply(compilation) {
 		const mainTemplate = compilation.mainTemplate;
-		compilation.templatesPlugin("render-with-entry", function(source, chunk, hash) {
+		compilation.templatesPlugin("render-with-entry", (source, chunk, hash) => {
 			let externals = chunk.getModules().filter(m => m.external);
 			const optionalExternals = [];
 			let requiredExternals = [];
@@ -172,19 +172,19 @@ class UmdMainTemplatePlugin {
 					"	}\n"
 				) +
 				"})(this, function(" + externalsArguments(externals) + ") {\nreturn ", "webpack/universalModuleDefinition"), source, ";\n})");
-		}.bind(this));
-		mainTemplate.plugin("global-hash-paths", function(paths) {
+		});
+		mainTemplate.plugin("global-hash-paths", (paths) => {
 			if(this.names.root) paths = paths.concat(this.names.root);
 			if(this.names.amd) paths = paths.concat(this.names.amd);
 			if(this.names.commonjs) paths = paths.concat(this.names.commonjs);
 			return paths;
-		}.bind(this));
-		mainTemplate.plugin("hash", function(hash) {
+		});
+		mainTemplate.plugin("hash", (hash) => {
 			hash.update("umd");
 			hash.update(`${this.names.root}`);
 			hash.update(`${this.names.amd}`);
 			hash.update(`${this.names.commonjs}`);
-		}.bind(this));
+		});
 	}
 }
 

package/lib/optimize/ConcatenatedModule.js

@@ -32,17 +32,16 @@ function ensureNsObjSource(info, moduleToInfoMap, requestShortener) {
 	}
 }
 
-function getExternalImport(importedModule, importedVar, exportName, asCall) {
-	const isHarmonyModule = importedModule && (!importedModule.meta || importedModule.meta.harmonyModule);
-	if(exportName === true) return importedVar;
+function getExternalImport(importedModule, info, exportName, asCall) {
+	if(exportName === true) return info.name;
 	const used = importedModule.isUsed(exportName);
 	if(!used) return "/* unused reexport */undefined";
-	if(!isHarmonyModule && exportName === "default") {
-		return asCall ? `${importedVar}_default()` : `${importedVar}_default.a`;
+	if(info.interop && exportName === "default") {
+		return asCall ? `${info.interopName}()` : `${info.interopName}.a`;
 	}
 	// TODO use Template.toNormalComment when merging with pure-module
 	const comment = used !== exportName ? ` /* ${exportName} */` : "";
-	const reference = `${importedVar}[${JSON.stringify(used)}${comment}]`;
+	const reference = `${info.name}[${JSON.stringify(used)}${comment}]`;
 	if(asCall)
 		return `Object(${reference})`;
 	return reference;
@@ -67,12 +66,6 @@ function getFinalName(info, exportName, moduleToInfoMap, requestShortener, asCal
 					if(refInfo) {
 						// module is in the concatenation
 						return getFinalName(refInfo, reexport.exportName, moduleToInfoMap, requestShortener, asCall);
-					} else {
-						const dep = reexport.dependency;
-						const importedModule = reexport.module;
-						const exportName = reexport.exportName;
-						const importedVar = dep.importedVar;
-						return getExternalImport(importedModule, importedVar, exportName, asCall);
 					}
 				}
 				const problem = `Cannot get final name for export "${exportName}" in "${info.module.readableIdentifier(requestShortener)}"` +
@@ -84,7 +77,7 @@ function getFinalName(info, exportName, moduleToInfoMap, requestShortener, asCal
 		case "external":
 			{
 				const importedModule = info.module;
-				return getExternalImport(importedModule, info.name, exportName, asCall);
+				return getExternalImport(importedModule, info, exportName, asCall);
 			}
 	}
 }
@@ -220,8 +213,19 @@ class ConcatenatedModule extends Module {
 		}
 	}
 
+	get modules() {
+		return this._orderedConcatenationList
+			.filter(info => info.type === "concatenated")
+			.map(info => info.module);
+	}
+
 	identifier() {
-		return this._orderedConcatenationList.map(info => info.module.identifier()).join(" ");
+		return this._orderedConcatenationList.map(info => {
+			switch(info.type) {
+				case "concatenated":
+					return info.module.identifier();
+			}
+		}).filter(Boolean).join(" ");
 	}
 
 	readableIdentifier(requestShortener) {
@@ -348,7 +352,6 @@ class ConcatenatedModule extends Module {
 							internalNames: new Map(),
 							exportMap: exportMap,
 							reexportMap: reexportMap,
-							needCompatibilityFlag: false,
 							hasNamespaceObject: false,
 							namespaceObjectSource: null
 						};
@@ -358,7 +361,9 @@ class ConcatenatedModule extends Module {
 						type: "external",
 						module: info.module,
 						index: idx,
-						name: undefined
+						name: undefined,
+						interopName: undefined,
+						interop: undefined
 					};
 				default:
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
@@ -453,6 +458,8 @@ class ConcatenatedModule extends Module {
 			"switch", "synchronized", "this", "throw", "throws", "transient", "true", "try", "typeof",
 			"var", "void", "volatile", "while", "with", "yield",
 
+			"module", "__dirname", "__filename", "exports",
+
 			"Array", "Date", "eval", "function", "hasOwnProperty", "Infinity", "isFinite", "isNaN",
 			"isPrototypeOf", "length", "Math", "NaN", "name", "Number", "Object", "prototype", "String",
 			"toString", "undefined", "valueOf",
@@ -526,9 +533,15 @@ class ConcatenatedModule extends Module {
 					}
 				case "external":
 					{
+						info.interop = info.module.meta && !info.module.meta.harmonyModule;
 						const externalName = this.findNewName("", allUsedNames, null, info.module.readableIdentifier(requestShortener));
 						allUsedNames.add(externalName);
 						info.name = externalName;
+						if(info.interop) {
+							const externalNameInterop = this.findNewName("default", allUsedNames, null, info.module.readableIdentifier(requestShortener));
+							allUsedNames.add(externalNameInterop);
+							info.interopName = externalNameInterop;
+						}
 						break;
 					}
 			}
@@ -562,7 +575,8 @@ class ConcatenatedModule extends Module {
 		const result = new ConcatSource();
 
 		// add harmony compatibility flag (must be first because of possible circular dependencies)
-		if(moduleToInfoMap.get(this.rootModule).needCompatibilityFlag) {
+		const usedExports = this.rootModule.usedExports;
+		if(usedExports === true) {
 			result.add(`Object.defineProperty(${this.exportsArgument || "exports"}, "__esModule", { value: true });\n`);
 		}
 
@@ -583,8 +597,8 @@ class ConcatenatedModule extends Module {
 				case "external":
 					result.add(`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(requestShortener)}\n`);
 					result.add(`var ${info.name} = __webpack_require__(${JSON.stringify(info.module.id)});\n`);
-					if(info.module.meta && !info.module.meta.harmonyModule) {
-						result.add(`var ${info.name}_default = /*#__PURE__*/__webpack_require__.n(${info.name});\n`);
+					if(info.interop) {
+						result.add(`var ${info.interopName} = /*#__PURE__*/__webpack_require__.n(${info.name});\n`);
 					}
 					break;
 				default:
@@ -793,9 +807,7 @@ class HarmonyCompatibilityDependencyConcatenatedTemplate {
 	}
 
 	apply(dep, source, outputOptions, requestShortener, dependencyTemplates) {
-		if(dep.originModule === this.rootModule) {
-			this.modulesMap.get(this.rootModule).needCompatibilityFlag = true;
-		}
+		// do nothing
 	}
 }
 

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -22,6 +22,7 @@ class EnsureChunkConditionsPlugin {
 							chunk.parents.forEach((parent) => {
 								if(!usedChunks.has(parent)) {
 									parent.addModule(module);
+									module.addChunk(parent);
 									newChunks.push(parent);
 								}
 							});

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -5,6 +5,8 @@
 "use strict";
 
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+const ModuleHotAcceptDependency = require("../dependencies/ModuleHotAcceptDependency");
+const ModuleHotDeclineDependency = require("../dependencies/ModuleHotDeclineDependency");
 const ConcatenatedModule = require("./ConcatenatedModule");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyCompatibilityDependency = require("../dependencies/HarmonyCompatibilityDependency");
@@ -67,6 +69,12 @@ class ModuleConcatenationPlugin {
 						continue;
 					}
 
+					// Hot Module Replacement need it's own module to work correctly
+					if(module.dependencies.some(dep => dep instanceof ModuleHotAcceptDependency || dep instanceof ModuleHotDeclineDependency)) {
+						setBailoutReason(module, "Module uses Hot Module Replacement");
+						continue;
+					}
+
 					relevantModules.push(module);
 
 					// Module must not be the entry points
@@ -155,6 +163,7 @@ class ModuleConcatenationPlugin {
 					}
 					chunks.forEach(chunk => {
 						chunk.addModule(newModule);
+						newModule.addChunk(chunk);
 						if(chunk.entryModule === concatConfiguration.rootModule)
 							chunk.entryModule = newModule;
 					});

package/lib/util/Semaphore.js

@@ -0,0 +1,32 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class Semaphore {
+	constructor(available) {
+		this.available = available;
+		this.waiters = [];
+	}
+
+	acquire(callback) {
+		if(this.available > 0) {
+			this.available--;
+			callback();
+		} else {
+			this.waiters.push(callback);
+		}
+	}
+
+	release() {
+		if(this.waiters.length > 0) {
+			const callback = this.waiters.pop();
+			process.nextTick(callback);
+		} else {
+			this.available++;
+		}
+	}
+}
+
+module.exports = Semaphore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "3.5.1",
+  "version": "3.5.5",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "dependencies": {
@@ -101,6 +101,7 @@
     "pretest": "npm run lint-files",
     "lint-files": "npm run lint && npm run beautify-lint",
     "lint": "eslint lib bin hot buildin \"test/**/webpack.config.js\" \"test/binCases/**/test.js\" \"examples/**/webpack.config.js\"",
+    "fix": "npm run lint -- --fix",
     "beautify-lint": "beautify-lint \"lib/**/*.js\" \"hot/**/*.js\" \"bin/**/*.js\" \"benchmark/*.js\" \"test/*.js\"",
     "nsp": "nsp check --output summary",
     "benchmark": "mocha --max-old-space-size=4096 --harmony test/*.benchmark.js -R spec",

package/schemas/webpackOptionsSchema.json

@@ -900,6 +900,11 @@
     "output": {
       "$ref": "#/definitions/output"
     },
+    "parallelism": {
+      "description": "The number of parallel processed modules in the compilation.",
+      "minimum": 1,
+      "type": "number"
+    },
     "performance": {
       "description": "Configuration for web performance recommendations.",
       "anyOf": [