root
/
webpack
mirror of https://github.com/webpack/webpack.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

cleanup, renaming

This commit is contained in:
Tobias Koppers 2020-01-29 14:24:55 +01:00
parent 432d338f9a
commit 77abab8c97
4 changed files with 77 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
lib/dependencies/HarmonyExportDependencyParserPlugin.js
View File

@ -5,7 +5,7 @@
"use strict";
const { topLevelSymbolTag } = require("../optimize/InnerGraph");
const InnerGraph = require("../optimize/InnerGraph");
const ConstDependency = require("./ConstDependency");
const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
@ -87,15 +87,13 @@ module.exports = class HarmonyExportDependencyParserPlugin {
dep.loc = Object.create(statement.loc);
dep.loc.index = -1;
parser.state.current.addDependency(dep);
const topLevelSymbol = parser.getTagData(
InnerGraph.addVariableUsage(
parser,
expr.type.endsWith("Declaration") && expr.id
? expr.id.name
: "*default*",
topLevelSymbolTag
"default"
);
if (topLevelSymbol) {
topLevelSymbol.addDependency("default");
}
return true;
}
);
@ -107,10 +105,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
const harmonyNamedExports = (parser.state.harmonyNamedExports =
parser.state.harmonyNamedExports || new Set());
harmonyNamedExports.add(name);
const topLevelSymbol = parser.getTagData(id, topLevelSymbolTag);
if (topLevelSymbol) {
topLevelSymbol.addDependency(name);
}
InnerGraph.addVariableUsage(parser, id, name);
if (settings) {
dep = new HarmonyExportImportedSpecifierDependency(
settings.source,

8
lib/dependencies/HarmonyImportDependencyParserPlugin.js
View File

@ -86,13 +86,9 @@ module.exports = class HarmonyImportDependencyParserPlugin {
InnerGraph.addDependency(parser.state, dep);
if (!currentTopLevelSymbol) {
InnerGraph.setUsage(parser.state, dep, true);
InnerGraph.addUsage(parser.state, dep, true);
} else {
InnerGraph.setUsage(
parser.state,
dep,
new Set([currentTopLevelSymbol])
);
InnerGraph.addUsage(parser.state, dep, currentTopLevelSymbol);
}
};
parser.hooks.expression

118
lib/optimize/InnerGraph.js
View File

@ -7,11 +7,10 @@
/** @typedef {import("estree").Node} AnyNode */
/** @typedef {import("../Dependency")} Dependency */
/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
/** @typedef {import("../dependencies/PureExpressionDependency")} PureExpressionDependency */
/** @typedef {import("../Parser").ParserState} ParserState */
/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
/** @typedef {Map<TopLevelSymbol | Dependency, Set<string | TopLevelSymbol> | true>} InnerGraph */
/** @typedef {false|{innerGraph: InnerGraph, allExportDependentDependencies: Set<PureExpressionDependency|HarmonyImportSpecifierDependency>, currentTopLevelSymbol: TopLevelSymbol|void}} State */
/** @typedef {false|{innerGraph: InnerGraph, allExportDependentDependencies: Set<Dependency>, currentTopLevelSymbol: TopLevelSymbol|void}} State */
/** @type {WeakMap<ParserState, State>} */
const parserStateMap = new WeakMap();
@ -61,32 +60,44 @@ exports.isEnabled = parserState => {
/**
* @param {ParserState} state parser state
* @param {TopLevelSymbol | Dependency} symbol the symbol
* @param {Set<string | TopLevelSymbol> | true} usage usage data
* @param {string | TopLevelSymbol | true} usage usage data
* @returns {void}
*/
exports.setUsage = (state, symbol, usage) => {
exports.addUsage = (state, symbol, usage) => {
const innerGraphState = getState(state);
if (innerGraphState) {
innerGraphState.innerGraph.set(symbol, usage);
const { innerGraph } = innerGraphState;
const info = innerGraph.get(symbol);
if (usage === true) {
innerGraph.set(symbol, true);
} else if (info === undefined) {
innerGraph.set(symbol, new Set([usage]));
} else if (info !== true) {
info.add(usage);
}
}
};
/**
* @param {JavascriptParser} parser the parser
* @param {string} name name of variable
* @param {string | TopLevelSymbol | true} usage usage data
* @returns {void}
*/
exports.addVariableUsage = (parser, name, usage) => {
const symbol = /** @type {TopLevelSymbol} */ (parser.getTagData(
name,
topLevelSymbolTag
));
if (symbol) {
exports.addUsage(parser.state, symbol, usage);
}
};
/**
* @param {ParserState} state parser state
* @param {TopLevelSymbol | Dependency} symbol the symbol
* @returns {Set<string | TopLevelSymbol> | true} usage data
*/
exports.getUsage = (state, symbol) => {
const innerGraphState = getState(state);
if (innerGraphState) {
return innerGraphState.innerGraph.get(symbol);
}
};
/**
* @param {ParserState} state parser state
* @returns {Map<Dependency, Set<string | TopLevelSymbol> | true>} usage data
* @returns {Map<Dependency, Set<string> | true>} usage data
*/
exports.inferDependencyUsage = state => {
const innerGraphState = getState(state);
@ -140,25 +151,18 @@ exports.inferDependencyUsage = state => {
}
}
/** @type {Map<Dependency, true | Set<string>>} */
const result = new Map();
for (const dep of allExportDependentDependencies) {
const value = innerGraph.get(dep);
switch (value) {
case undefined:
dep.usedByExports = false;
break;
case true:
dep.usedByExports = true;
break;
default:
dep.usedByExports = /** @type {Set<string>} */ (value);
break;
}
const value = /** @type {true | Set<string>} */ (innerGraph.get(dep));
result.set(dep, value);
}
return result;
};
/**
* @param {ParserState} state parser state
* @param {PureExpressionDependency|HarmonyImportSpecifierDependency} dep dependency
* @param {Dependency} dep dependency
*/
exports.addDependency = (state, dep) => {
const innerGraphState = getState(state);
@ -193,61 +197,35 @@ exports.getTopLevelSymbol = state => {
};
/**
* @param {ParserState} state parser state
* @returns {Set<PureExpressionDependency|HarmonyImportSpecifierDependency>} dependencies
*/
exports.getExportDependentDependencies = state => {
const innerGraphState = getState(state);
if (innerGraphState) {
return innerGraphState.allExportDependentDependencies;
}
};
/**
* @param {TODO} parser parser
* @param {string} name symbol name
* @returns {TopLevelSymbol} usage data
* @param {JavascriptParser} parser parser
* @param {string} name name of variable
* @returns {TopLevelSymbol} symbol
*/
exports.tagTopLevelSymbol = (parser, name) => {
const innerGraphState = getState(parser.state);
const { innerGraph } = innerGraphState || {};
if (!innerGraphState) return;
parser.defineVariable(name);
const existingTag = parser.getTagData(name, topLevelSymbolTag);
const existingTag = /** @type {TopLevelSymbol} */ (parser.getTagData(
name,
topLevelSymbolTag
));
if (existingTag) {
return existingTag;
}
const fn = new TopLevelSymbol(name, innerGraph);
const fn = new TopLevelSymbol(name);
parser.tagVariable(name, topLevelSymbolTag, fn);
return fn;
};
class TopLevelSymbol {
/**
* @param {string} name name of the function
* @param {InnerGraph} innerGraph reference to the graph
* @param {string} name name of the variable
*/
constructor(name, innerGraph) {
constructor(name) {
this.name = name;
this.innerGraph = innerGraph;
}
/**
* @param {string | TopLevelSymbol | true} dep export or top level symbol or always
* @returns {void}
*/
addDependency(dep) {
const info = this.innerGraph.get(this);
if (dep === true) {
this.innerGraph.set(this, true);
} else if (info === undefined) {
this.innerGraph.set(this, new Set([dep]));
} else if (info !== true) {
info.add(dep);
}
}
}

25
lib/optimize/InnerGraphPlugin.js
View File

@ -118,7 +118,22 @@ class InnerGraphPlugin {
parser.hooks.finish.tap("InnerGraphPlugin", () => {
if (!InnerGraph.isEnabled(parser.state)) return;
InnerGraph.inferDependencyUsage(parser.state);
for (const [dependency, usage] of InnerGraph.inferDependencyUsage(
parser.state
)) {
const dep = /** @type {Dependency & { usedByExports: boolean | Set<string> }} */ (dependency);
switch (usage) {
case undefined:
dep.usedByExports = false;
break;
case true:
dep.usedByExports = true;
break;
default:
dep.usedByExports = usage;
break;
}
}
});
/** @type {WeakMap<{}, TopLevelSymbol>} */
const statementWithTopLevelSymbol = new WeakMap();
@ -209,7 +224,7 @@ class InnerGraphPlugin {
const dep = new PureExpressionDependency(decl.init.range);
dep.loc = decl.loc;
parser.state.module.addDependency(dep);
InnerGraph.setUsage(parser.state, dep, new Set([fn]));
InnerGraph.addUsage(parser.state, dep, fn);
InnerGraph.addDependency(parser.state, dep);
}
InnerGraph.setTopLevelSymbol(parser.state, fn);
@ -226,7 +241,11 @@ class InnerGraphPlugin {
const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
parser.state
);
topLevelSymbol.addDependency(currentTopLevelSymbol || true);
InnerGraph.addUsage(
parser.state,
topLevelSymbol,
currentTopLevelSymbol || true
);
});
parser.hooks.assign
.for(topLevelSymbolTag)