Skip to content

Commit c10da6c

Browse files
sokrasokra
committed
upgrade tapable from Parser
1 parent 3f453a4 commit c10da6c

8 files changed

Lines changed: 330 additions & 229 deletions

‎lib/HotModuleReplacementPlugin.js‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ const ConstDependency = require("./dependencies/ConstDependency");
1111
const NullFactory = require("./NullFactory");
1212
const ParserHelpers = require("./ParserHelpers");
1313
const createHash = require("./util/createHash");
14+
const SyncBailHook = require("tapable").SyncBailHook;
1415

1516
module.exports = class HotModuleReplacementPlugin {
1617
constructor(options) {
@@ -198,6 +199,11 @@ module.exports = class HotModuleReplacementPlugin {
198199
parser.plugin("evaluate Identifier module.hot", expr => {
199200
return ParserHelpers.evaluateToIdentifier("module.hot", !!parser.state.compilation.hotUpdateChunkTemplate)(expr);
200201
});
202+
// TODO webpack 5: refactor this, no custom hooks
203+
if(!parser.hooks.hotAcceptCallback)
204+
parser.hooks.hotAcceptCallback = new SyncBailHook(["expression", "requests"]);
205+
if(!parser.hooks.hotAcceptWithoutCallback)
206+
parser.hooks.hotAcceptWithoutCallback = new SyncBailHook(["expression", "requests"]);
201207
parser.plugin("call module.hot.accept", expr => {
202208
if(!parser.state.compilation.hotUpdateChunkTemplate) return false;
203209
if(expr.arguments.length >= 1) {
@@ -220,9 +226,9 @@ module.exports = class HotModuleReplacementPlugin {
220226
requests.push(request);
221227
});
222228
if(expr.arguments.length > 1)
223-
parser.applyPluginsBailResult("hot accept callback", expr.arguments[1], requests);
229+
parser.hooks.hotAcceptCallback.call(expr.arguments[1], requests);
224230
else
225-
parser.applyPluginsBailResult("hot accept without callback", expr, requests);
231+
parser.hooks.hotAcceptWithoutCallback.call(expr, requests);
226232
}
227233
}
228234
});

‎lib/Parser.js‎

Lines changed: 129 additions & 53 deletions
Large diffs are not rendered by default.

‎lib/dependencies/AMDDefineDependencyParserPlugin.js‎

Lines changed: 78 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,83 @@ class AMDDefineDependencyParserPlugin {
4646

4747
apply(parser) {
4848
const options = this.options;
49+
50+
const processArray = (expr, param, identifiers, namedModule) => {
51+
if(param.isArray()) {
52+
param.items.forEach((param, idx) => {
53+
if(param.isString() && ["require", "module", "exports"].indexOf(param.string) >= 0)
54+
identifiers[idx] = param.string;
55+
const result = processItem(expr, param, namedModule);
56+
if(result === undefined) {
57+
processContext(expr, param);
58+
}
59+
});
60+
return true;
61+
} else if(param.isConstArray()) {
62+
const deps = [];
63+
param.array.forEach((request, idx) => {
64+
let dep;
65+
let localModule;
66+
if(request === "require") {
67+
identifiers[idx] = request;
68+
dep = "__webpack_require__";
69+
} else if(["exports", "module"].indexOf(request) >= 0) {
70+
identifiers[idx] = request;
71+
dep = request;
72+
} else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, request)) { // eslint-disable-line no-cond-assign
73+
dep = new LocalModuleDependency(localModule);
74+
dep.loc = expr.loc;
75+
parser.state.current.addDependency(dep);
76+
} else {
77+
dep = new AMDRequireItemDependency(request);
78+
dep.loc = expr.loc;
79+
dep.optional = !!parser.scope.inTry;
80+
parser.state.current.addDependency(dep);
81+
}
82+
deps.push(dep);
83+
});
84+
const dep = new AMDRequireArrayDependency(deps, param.range);
85+
dep.loc = expr.loc;
86+
dep.optional = !!parser.scope.inTry;
87+
parser.state.current.addDependency(dep);
88+
return true;
89+
}
90+
};
91+
const processItem = (expr, param, namedModule) => {
92+
if(param.isConditional()) {
93+
param.options.forEach((param) => {
94+
const result = processItem(expr, param);
95+
if(result === undefined) {
96+
processContext(expr, param);
97+
}
98+
});
99+
return true;
100+
} else if(param.isString()) {
101+
let dep, localModule;
102+
if(param.string === "require") {
103+
dep = new ConstDependency("__webpack_require__", param.range);
104+
} else if(["require", "exports", "module"].indexOf(param.string) >= 0) {
105+
dep = new ConstDependency(param.string, param.range);
106+
} else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string, namedModule)) { // eslint-disable-line no-cond-assign
107+
dep = new LocalModuleDependency(localModule, param.range);
108+
} else {
109+
dep = new AMDRequireItemDependency(param.string, param.range);
110+
}
111+
dep.loc = expr.loc;
112+
dep.optional = !!parser.scope.inTry;
113+
parser.state.current.addDependency(dep);
114+
return true;
115+
}
116+
};
117+
const processContext = (expr, param) => {
118+
const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
119+
if(!dep) return;
120+
dep.loc = expr.loc;
121+
dep.optional = !!parser.scope.inTry;
122+
parser.state.current.addDependency(dep);
123+
return true;
124+
};
125+
49126
parser.plugin("call define", (expr) => {
50127
let array, fn, obj, namedModule;
51128
switch(expr.arguments.length) {
@@ -126,7 +203,7 @@ class AMDDefineDependencyParserPlugin {
126203
if(array) {
127204
identifiers = {};
128205
const param = parser.evaluateExpression(array);
129-
const result = parser.applyPluginsBailResult("call define:amd:array", expr, param, identifiers, namedModule);
206+
const result = processArray(expr, param, identifiers, namedModule);
130207
if(!result) return;
131208
if(fnParams) fnParams = fnParams.slice(fnParamsOffset).filter((param, idx) => {
132209
if(identifiers[idx]) {
@@ -186,81 +263,6 @@ class AMDDefineDependencyParserPlugin {
186263
parser.state.current.addDependency(dep);
187264
return true;
188265
});
189-
parser.plugin("call define:amd:array", (expr, param, identifiers, namedModule) => {
190-
if(param.isArray()) {
191-
param.items.forEach((param, idx) => {
192-
if(param.isString() && ["require", "module", "exports"].indexOf(param.string) >= 0)
193-
identifiers[idx] = param.string;
194-
const result = parser.applyPluginsBailResult("call define:amd:item", expr, param, namedModule);
195-
if(result === undefined) {
196-
parser.applyPluginsBailResult("call define:amd:context", expr, param);
197-
}
198-
});
199-
return true;
200-
} else if(param.isConstArray()) {
201-
const deps = [];
202-
param.array.forEach((request, idx) => {
203-
let dep;
204-
let localModule;
205-
if(request === "require") {
206-
identifiers[idx] = request;
207-
dep = "__webpack_require__";
208-
} else if(["exports", "module"].indexOf(request) >= 0) {
209-
identifiers[idx] = request;
210-
dep = request;
211-
} else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, request)) { // eslint-disable-line no-cond-assign
212-
dep = new LocalModuleDependency(localModule);
213-
dep.loc = expr.loc;
214-
parser.state.current.addDependency(dep);
215-
} else {
216-
dep = new AMDRequireItemDependency(request);
217-
dep.loc = expr.loc;
218-
dep.optional = !!parser.scope.inTry;
219-
parser.state.current.addDependency(dep);
220-
}
221-
deps.push(dep);
222-
});
223-
const dep = new AMDRequireArrayDependency(deps, param.range);
224-
dep.loc = expr.loc;
225-
dep.optional = !!parser.scope.inTry;
226-
parser.state.current.addDependency(dep);
227-
return true;
228-
}
229-
});
230-
parser.plugin("call define:amd:item", (expr, param, namedModule) => {
231-
if(param.isConditional()) {
232-
param.options.forEach((param) => {
233-
const result = parser.applyPluginsBailResult("call define:amd:item", expr, param);
234-
if(result === undefined) {
235-
parser.applyPluginsBailResult("call define:amd:context", expr, param);
236-
}
237-
});
238-
return true;
239-
} else if(param.isString()) {
240-
let dep, localModule;
241-
if(param.string === "require") {
242-
dep = new ConstDependency("__webpack_require__", param.range);
243-
} else if(["require", "exports", "module"].indexOf(param.string) >= 0) {
244-
dep = new ConstDependency(param.string, param.range);
245-
} else if(localModule = LocalModulesHelpers.getLocalModule(parser.state, param.string, namedModule)) { // eslint-disable-line no-cond-assign
246-
dep = new LocalModuleDependency(localModule, param.range);
247-
} else {
248-
dep = new AMDRequireItemDependency(param.string, param.range);
249-
}
250-
dep.loc = expr.loc;
251-
dep.optional = !!parser.scope.inTry;
252-
parser.state.current.addDependency(dep);
253-
return true;
254-
}
255-
});
256-
parser.plugin("call define:amd:context", (expr, param) => {
257-
const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
258-
if(!dep) return;
259-
dep.loc = expr.loc;
260-
dep.optional = !!parser.scope.inTry;
261-
parser.state.current.addDependency(dep);
262-
return true;
263-
});
264266
}
265267
}
266268
module.exports = AMDDefineDependencyParserPlugin;

‎lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js‎

Lines changed: 65 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -45,67 +45,13 @@ class AMDRequireDependenciesBlockParserPlugin {
4545

4646
apply(parser) {
4747
const options = this.options;
48-
parser.plugin("call require", (expr) => {
49-
let param;
50-
let dep;
51-
let result;
52-
53-
const old = parser.state.current;
54-
55-
if(expr.arguments.length >= 1) {
56-
param = parser.evaluateExpression(expr.arguments[0]);
57-
dep = new AMDRequireDependenciesBlock(
58-
expr,
59-
param.range,
60-
(expr.arguments.length > 1) ? expr.arguments[1].range : null,
61-
(expr.arguments.length > 2) ? expr.arguments[2].range : null,
62-
parser.state.module,
63-
expr.loc
64-
);
65-
parser.state.current = dep;
66-
}
67-
68-
if(expr.arguments.length === 1) {
69-
parser.inScope([], () => {
70-
result = parser.applyPluginsBailResult("call require:amd:array", expr, param);
71-
});
72-
parser.state.current = old;
73-
if(!result) return;
74-
parser.state.current.addBlock(dep);
75-
return true;
76-
}
7748

78-
if(expr.arguments.length === 2 || expr.arguments.length === 3) {
79-
try {
80-
parser.inScope([], () => {
81-
result = parser.applyPluginsBailResult("call require:amd:array", expr, param);
82-
});
83-
if(!result) {
84-
dep = new UnsupportedDependency("unsupported", expr.range);
85-
old.addDependency(dep);
86-
if(parser.state.module)
87-
parser.state.module.errors.push(new UnsupportedFeatureWarning(parser.state.module, "Cannot statically analyse 'require(..., ...)' in line " + expr.loc.start.line));
88-
dep = null;
89-
return true;
90-
}
91-
dep.functionBindThis = this.processFunctionArgument(parser, expr.arguments[1]);
92-
if(expr.arguments.length === 3) {
93-
dep.errorCallbackBindThis = this.processFunctionArgument(parser, expr.arguments[2]);
94-
}
95-
} finally {
96-
parser.state.current = old;
97-
if(dep)
98-
parser.state.current.addBlock(dep);
99-
}
100-
return true;
101-
}
102-
});
103-
parser.plugin("call require:amd:array", (expr, param) => {
49+
const processArray = (expr, param) => {
10450
if(param.isArray()) {
10551
param.items.forEach((param) => {
106-
const result = parser.applyPluginsBailResult("call require:amd:item", expr, param);
52+
const result = processItem(expr, param);
10753
if(result === undefined) {
108-
parser.applyPluginsBailResult("call require:amd:context", expr, param);
54+
processContext(expr, param);
10955
}
11056
});
11157
return true;
@@ -135,13 +81,13 @@ class AMDRequireDependenciesBlockParserPlugin {
13581
parser.state.current.addDependency(dep);
13682
return true;
13783
}
138-
});
139-
parser.plugin("call require:amd:item", (expr, param) => {
84+
};
85+
const processItem = (expr, param) => {
14086
if(param.isConditional()) {
14187
param.options.forEach((param) => {
142-
const result = parser.applyPluginsBailResult("call require:amd:item", expr, param);
88+
const result = processItem(expr, param);
14389
if(result === undefined) {
144-
parser.applyPluginsBailResult("call require:amd:context", expr, param);
90+
processContext(expr, param);
14591
}
14692
});
14793
return true;
@@ -163,14 +109,70 @@ class AMDRequireDependenciesBlockParserPlugin {
163109
parser.state.current.addDependency(dep);
164110
return true;
165111
}
166-
});
167-
parser.plugin("call require:amd:context", (expr, param) => {
112+
};
113+
const processContext = (expr, param) => {
168114
const dep = ContextDependencyHelpers.create(AMDRequireContextDependency, param.range, param, expr, options);
169115
if(!dep) return;
170116
dep.loc = expr.loc;
171117
dep.optional = !!parser.scope.inTry;
172118
parser.state.current.addDependency(dep);
173119
return true;
120+
};
121+
122+
parser.plugin("call require", (expr) => {
123+
let param;
124+
let dep;
125+
let result;
126+
127+
const old = parser.state.current;
128+
129+
if(expr.arguments.length >= 1) {
130+
param = parser.evaluateExpression(expr.arguments[0]);
131+
dep = new AMDRequireDependenciesBlock(
132+
expr,
133+
param.range,
134+
(expr.arguments.length > 1) ? expr.arguments[1].range : null,
135+
(expr.arguments.length > 2) ? expr.arguments[2].range : null,
136+
parser.state.module,
137+
expr.loc
138+
);
139+
parser.state.current = dep;
140+
}
141+
142+
if(expr.arguments.length === 1) {
143+
parser.inScope([], () => {
144+
result = processArray(expr, param);
145+
});
146+
parser.state.current = old;
147+
if(!result) return;
148+
parser.state.current.addBlock(dep);
149+
return true;
150+
}
151+
152+
if(expr.arguments.length === 2 || expr.arguments.length === 3) {
153+
try {
154+
parser.inScope([], () => {
155+
result = processArray(expr, param);
156+
});
157+
if(!result) {
158+
dep = new UnsupportedDependency("unsupported", expr.range);
159+
old.addDependency(dep);
160+
if(parser.state.module)
161+
parser.state.module.errors.push(new UnsupportedFeatureWarning(parser.state.module, "Cannot statically analyse 'require(..., ...)' in line " + expr.loc.start.line));
162+
dep = null;
163+
return true;
164+
}
165+
dep.functionBindThis = this.processFunctionArgument(parser, expr.arguments[1]);
166+
if(expr.arguments.length === 3) {
167+
dep.errorCallbackBindThis = this.processFunctionArgument(parser, expr.arguments[2]);
168+
}
169+
} finally {
170+
parser.state.current = old;
171+
if(dep)
172+
parser.state.current.addBlock(dep);
173+
}
174+
return true;
175+
}
174176
});
175177
}
176178
}

0 commit comments

Comments
 (0)