use Set for ModuleReason chunk rewriting

lib/Module.js

@@ -9,13 +9,6 @@ const DependenciesBlock = require("./DependenciesBlock");
 const ModuleReason = require("./ModuleReason");
 const Template = require("./Template");
 
-function addToSet(set, items) {
-	for(const item of items) {
-		if(set.indexOf(item) < 0)
-			set.push(item);
-	}
-}
-
 function byId(a, b) {
 	return a.id - b.id;
 }
@@ -161,28 +154,17 @@ class Module extends DependenciesBlock {
 	}
 
 	hasReasonForChunk(chunk) {
-		for(const r of this.reasons) {
-			if(r.chunks) {
-				if(r.chunks.indexOf(chunk) >= 0)
-					return true;
-			} else if(r.module._chunks.has(chunk))
+		for(let i = 0; i < this.reasons.length; i++) {
+			if(this.reasons[i].hasChunk(chunk))
 				return true;
 		}
 		return false;
 	}
 
 	rewriteChunkInReasons(oldChunk, newChunks) {
-		this.reasons.forEach(r => {
-			if(!r.chunks) {
-				if(!r.module._chunks.has(oldChunk))
-					return;
-				r.chunks = Array.from(r.module._chunks);
-			}
-			r.chunks = r.chunks.reduce((arr, c) => {
-				addToSet(arr, c !== oldChunk ? [c] : newChunks);
-				return arr;
-			}, []);
-		});
+		for(let i = 0; i < this.reasons.length; i++) {
+			this.reasons[i].rewriteChunks(oldChunk, newChunks);
+		}
 	}
 
 	isUsed(exportName) {

lib/ModuleReason.js

@@ -4,9 +4,47 @@
 */
 "use strict";
 
-module.exports = class ModuleReason {
+const util = require("util");
+
+class ModuleReason {
 	constructor(module, dependency) {
 		this.module = module;
 		this.dependency = dependency;
+		this._chunks = null;
+	}
+
+	hasChunk(chunk) {
+		if(this._chunks) {
+			if(this._chunks.has(chunk))
+				return true;
+		} else if(this.module._chunks.has(chunk))
+			return true;
+		return false;
+	}
+
+	rewriteChunks(oldChunk, newChunks) {
+		if(!this._chunks) {
+			if(!this.module._chunks.has(oldChunk))
+				return;
+			this._chunks = new Set(this.module._chunks);
+		}
+		if(this._chunks.has(oldChunk)) {
+			this._chunks.delete(oldChunk);
+			for(let i = 0; i < newChunks.length; i++) {
+				this._chunks.add(newChunks[i]);
+			}
+		}
+	}
+}
+
+Object.defineProperty(ModuleReason.prototype, "chunks", {
+	configurable: false,
+	get: util.deprecate(function() {
+		return this._chunks ? Array.from(this._chunks) : null;
+	}, "ModuleReason.chunks: Use ModuleReason.hasChunk/rewriteChunks instead"),
+	set() {
+		throw new Error("Readonly. Use ModuleReason.rewriteChunks to modify chunks.");
 	}
-};
+});
+
+module.exports = ModuleReason;

test/ModuleReason.test.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const Module = require("../lib/Module");
+const Chunk = require("../lib/Chunk");
+const Dependency = require("../lib/Dependency");
+const ModuleReason = require("../lib/ModuleReason");
+const should = require("should");
+
+describe("ModuleReason", () => {
+	let myModule;
+	let myDependency;
+	let myModuleReason;
+	let myChunk;
+	let myChunk2;
+
+	beforeEach(() => {
+		myModule = new Module();
+		myDependency = new Dependency();
+		myChunk = new Chunk("chunk-test", "module-test", "loc-test");
+		myChunk2 = new Chunk("chunk-test", "module-test", "loc-test");
+
+		myModuleReason = new ModuleReason(myModule, myDependency);
+	});
+
+	describe("hasChunk", () => {
+		it("returns false when chunk is not present", () => should(myModuleReason.hasChunk(myChunk)).be.false());
+
+		it("returns true when chunk is present", () => {
+			myModuleReason.module.addChunk(myChunk);
+			should(myModuleReason.hasChunk(myChunk)).be.true();
+		});
+	});
+
+	describe("rewriteChunks", () => {
+		it("if old chunk is present, it is replaced with new chunks", () => {
+			myModuleReason.module.addChunk(myChunk);
+			myModuleReason.rewriteChunks(myChunk, [myChunk2]);
+
+			should(myModuleReason.hasChunk(myChunk)).be.false();
+			should(myModuleReason.hasChunk(myChunk2)).be.true();
+		});
+
+		it("if old chunk is not present, new chunks are not added", () => {
+			myModuleReason.rewriteChunks(myChunk, [myChunk2]);
+
+			should(myModuleReason.hasChunk(myChunk)).be.false();
+			should(myModuleReason.hasChunk(myChunk2)).be.false();
+		});
+
+		it("if already rewritten chunk is present, it is replaced with new chunks", () => {
+			myModuleReason.module.addChunk(myChunk);
+			myModuleReason.rewriteChunks(myChunk, [myChunk2]);
+			myModuleReason.rewriteChunks(myChunk2, [myChunk]);
+
+			should(myModuleReason.hasChunk(myChunk)).be.true();
+			should(myModuleReason.hasChunk(myChunk2)).be.false();
+		});
+	});
+
+	describe(".chunks", () => {
+		it("is null if no rewrites happen first", () => {
+			should(myModuleReason.chunks).be.Null();
+		});
+
+		it("is null if only invalid rewrites happen first", () => {
+			myModuleReason.rewriteChunks(myChunk, [myChunk2]);
+			should(myModuleReason.chunks).be.Null();
+		});
+
+		it("is an array of chunks if a valid rewrite happens", () => {
+			myModuleReason.module.addChunk(myChunk);
+			myModuleReason.rewriteChunks(myChunk, [myChunk2]);
+
+			should(myModuleReason.chunks).be.eql([myChunk2]);
+		});
+	});
+});