Function inferDependencyUsage

lib/optimize/InnerGraph.js:343–445

* @param {Module} module module * @returns {void}

(module)

	 * @returns {void}
	 */
	function inferDependencyUsage(module) {
		const innerGraphState = states.get(module);

		if (!innerGraphState) {
			return;
		}

		const { innerGraph, usageCallbackMap } = innerGraphState;
		/** @type {Map<InnerGraphKey, InnerGraphValueSet | undefined>} */
		const processed = new Map();
		// flatten graph to terminal nodes (string, undefined or true)
		const nonTerminal = new Set(innerGraph.keys());
		while (nonTerminal.size > 0) {
			for (const key of nonTerminal) {
				if (key !== null && !key.isPure(compilation, module)) {
					innerGraph.set(key, true);
					nonTerminal.delete(key);
					continue;
				}

				/** @type {InnerGraphValue} */
				let newSet = new Set();
				let isTerminal = true;
				const value = innerGraph.get(key);
				let alreadyProcessed = processed.get(key);
				if (alreadyProcessed === undefined) {
					/** @type {InnerGraphValueSet} */
					alreadyProcessed = new Set();
					processed.set(key, alreadyProcessed);
				}
				if (value !== true && value !== undefined) {
					for (const item of value) {
						alreadyProcessed.add(item);
					}
					for (const item of value) {
						if (typeof item === "string") {
							newSet.add(item);
						} else if (!item.isPure(compilation, module)) {
							newSet = true;
							break;
						} else {
							const itemValue = innerGraph.get(item);
							if (itemValue === true) {
								newSet = true;
								break;
							}
							if (itemValue !== undefined) {
								for (const i of itemValue) {
									if (i === key) continue;
									if (alreadyProcessed.has(i)) continue;
									newSet.add(i);
									if (typeof i !== "string") {
										isTerminal = false;
									}
								}
							}
						}
					}