From 363723fc84f7b8477592e0105aeb331ec9a017af Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Mon, 14 Aug 2017 05:01:11 +0200 Subject: node_modules --- node_modules/webpack/lib/Compilation.js | 427 ++++++++++++++++++++------------ 1 file changed, 264 insertions(+), 163 deletions(-) (limited to 'node_modules/webpack/lib/Compilation.js') diff --git a/node_modules/webpack/lib/Compilation.js b/node_modules/webpack/lib/Compilation.js index 4ac48da50..b59c0eb53 100644 --- a/node_modules/webpack/lib/Compilation.js +++ b/node_modules/webpack/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 = {}; @@ -80,6 +83,8 @@ class Compilation extends Tapable { this.children = []; this.dependencyFactories = new Map(); this.dependencyTemplates = new Map(); + this.dependencyTemplates.set("hash", ""); + this.childrenCounters = {}; } getStats() { @@ -112,8 +117,6 @@ class Compilation extends Tapable { cacheModule.errors.forEach(err => this.errors.push(err), this); cacheModule.warnings.forEach(err => this.warnings.push(err), this); return cacheModule; - } else { - module.lastId = cacheModule.id; } } module.unbuild(); @@ -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); + }); + } + }); }); } @@ -511,7 +528,7 @@ class Compilation extends Tapable { if(err) return callback(err); deps.forEach(d => { if(d.module && d.module.removeReason(module, d)) { - module.chunks.forEach(chunk => { + module.forEachChunk(chunk => { if(!d.module.hasReasonForChunk(chunk)) { if(d.module.removeChunk(chunk)) { this.removeChunkFromDependencies(d.module, chunk); @@ -568,12 +585,12 @@ class Compilation extends Tapable { while(self.applyPluginsBailResult1("optimize-modules-basic", self.modules) || self.applyPluginsBailResult1("optimize-modules", self.modules) || - self.applyPluginsBailResult1("optimize-modules-advanced", self.modules)); // eslint-disable-line no-extra-semi + self.applyPluginsBailResult1("optimize-modules-advanced", self.modules)) { /* empty */ } self.applyPlugins1("after-optimize-modules", self.modules); while(self.applyPluginsBailResult1("optimize-chunks-basic", self.chunks) || self.applyPluginsBailResult1("optimize-chunks", self.chunks) || - self.applyPluginsBailResult1("optimize-chunks-advanced", self.chunks)); // eslint-disable-line no-extra-semi + self.applyPluginsBailResult1("optimize-chunks-advanced", self.chunks)) { /* empty */ } self.applyPlugins1("after-optimize-chunks", self.chunks); self.applyPluginsAsyncSeries("optimize-tree", self.chunks, self.modules, function sealPart2(err) { @@ -583,6 +600,11 @@ class Compilation extends Tapable { self.applyPlugins2("after-optimize-tree", self.chunks, self.modules); + while(self.applyPluginsBailResult("optimize-chunk-modules-basic", self.chunks, self.modules) || + self.applyPluginsBailResult("optimize-chunk-modules", self.chunks, self.modules) || + self.applyPluginsBailResult("optimize-chunk-modules-advanced", self.chunks, self.modules)) { /* empty */ } + self.applyPlugins2("after-optimize-chunk-modules", self.chunks, self.modules); + const shouldRecord = self.applyPluginsBailResult("should-record") !== false; self.applyPlugins2("revive-modules", self.modules, self.records); @@ -824,7 +846,11 @@ class Compilation extends Tapable { } } - processDependenciesBlockForChunk(block, chunk) { + processDependenciesBlockForChunk(module, chunk) { + let block = module; + const initialChunk = chunk; + const chunkDependencies = new Map(); // Map> + const iteratorBlock = b => { let c; if(!b.chunks) { @@ -834,9 +860,17 @@ class Compilation extends Tapable { } else { c = b.chunks[0]; } - chunk.addChunk(c); - c.addParent(chunk); - queue.push([b, c]); + let deps = chunkDependencies.get(chunk); + if(!deps) chunkDependencies.set(chunk, deps = []); + deps.push({ + chunk: c, + module + }); + queue.push({ + block: b, + module: null, + chunk: c + }); }; const iteratorDependency = d => { @@ -848,18 +882,25 @@ class Compilation extends Tapable { } if(chunk.addModule(d.module)) { d.module.addChunk(chunk); - queue.push([d.module, chunk]); + queue.push({ + block: d.module, + module: d.module, + chunk + }); } }; - const queue = [ - [block, chunk] - ]; + const queue = [{ + block, + module, + chunk + }]; while(queue.length) { const queueItem = queue.pop(); - block = queueItem[0]; - chunk = queueItem[1]; + block = queueItem.block; + module = queueItem.module; + chunk = queueItem.chunk; if(block.variables) { iterationBlockVariable(block.variables, iteratorDependency); @@ -873,6 +914,47 @@ class Compilation extends Tapable { iterationOfArrayCallback(block.blocks, iteratorBlock); } } + + chunk = initialChunk; + let chunks = new Set(); + const queue2 = [{ + chunk, + chunks + }]; + + const filterFn = dep => { + if(chunks.has(dep.chunk)) return false; + for(const chunk of chunks) { + if(chunk.containsModule(dep.module)) + return false; + } + return true; + }; + + while(queue2.length) { + const queueItem = queue2.pop(); + chunk = queueItem.chunk; + chunks = queueItem.chunks; + + const deps = chunkDependencies.get(chunk); + if(!deps) continue; + + const depsFiltered = deps.filter(filterFn); + + for(let i = 0; i < depsFiltered.length; i++) { + const dep = depsFiltered[i]; + const depChunk = dep.chunk; + chunk.addChunk(depChunk); + depChunk.addParent(chunk); + + const newChunks = depsFiltered.length > 1 ? new Set(chunks) : chunks; + newChunks.add(chunk); + queue2.push({ + chunk: depChunk, + chunks: newChunks + }); + } + } } removeChunkFromDependencies(block, chunk) { @@ -1017,7 +1099,7 @@ class Compilation extends Tapable { const modules = this.modules; for(let indexModule = 0; indexModule < modules.length; indexModule++) { - modules[indexModule].sortItems(); + modules[indexModule].sortItems(false); } const chunks = this.chunks; @@ -1031,13 +1113,24 @@ class Compilation extends Tapable { const modules = this.modules; for(let indexModule = 0; indexModule < modules.length; indexModule++) { - modules[indexModule].sortItems(); + modules[indexModule].sortItems(true); } const chunks = this.chunks; 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() { @@ -1106,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(); /** @@ -1218,8 +1317,10 @@ class Compilation extends Tapable { return this.mainTemplate.applyPluginsWaterfall("asset-path", filename, data); } - createChildCompiler(name, outputOptions) { - return this.compiler.createChildCompiler(this, name, outputOptions); + createChildCompiler(name, outputOptions, plugins) { + var idx = (this.childrenCounters[name] || 0); + this.childrenCounters[name] = idx + 1; + return this.compiler.createChildCompiler(this, name, idx, outputOptions, plugins); } checkConstraints() { -- cgit v1.2.3