AMDRequireDependenciesBlockParserPlugin.js 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418
  1. /*
  2. MIT License http://www.opensource.org/licenses/mit-license.php
  3. Author Tobias Koppers @sokra
  4. */
  5. "use strict";
  6. const RuntimeGlobals = require("../RuntimeGlobals");
  7. const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
  8. const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
  9. const AMDRequireContextDependency = require("./AMDRequireContextDependency");
  10. const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");
  11. const AMDRequireDependency = require("./AMDRequireDependency");
  12. const AMDRequireItemDependency = require("./AMDRequireItemDependency");
  13. const ConstDependency = require("./ConstDependency");
  14. const ContextDependencyHelpers = require("./ContextDependencyHelpers");
  15. const LocalModuleDependency = require("./LocalModuleDependency");
  16. const { getLocalModule } = require("./LocalModulesHelpers");
  17. const UnsupportedDependency = require("./UnsupportedDependency");
  18. const getFunctionExpression = require("./getFunctionExpression");
  19. /** @typedef {import("estree").CallExpression} CallExpression */
  20. /** @typedef {import("estree").Expression} Expression */
  21. /** @typedef {import("estree").Identifier} Identifier */
  22. /** @typedef {import("estree").SourceLocation} SourceLocation */
  23. /** @typedef {import("estree").SpreadElement} SpreadElement */
  24. /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
  25. /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
  26. /** @typedef {import("../Module").BuildInfo} BuildInfo */
  27. /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
  28. /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
  29. /** @typedef {import("../javascript/JavascriptParser").Range} Range */
  30. class AMDRequireDependenciesBlockParserPlugin {
  31. /**
  32. * @param {JavascriptParserOptions} options parserOptions
  33. */
  34. constructor(options) {
  35. this.options = options;
  36. }
  37. /**
  38. * @param {JavascriptParser} parser the parser
  39. * @param {Expression | SpreadElement} expression expression
  40. * @returns {boolean} need bind this
  41. */
  42. processFunctionArgument(parser, expression) {
  43. let bindThis = true;
  44. const fnData = getFunctionExpression(expression);
  45. if (fnData) {
  46. parser.inScope(
  47. fnData.fn.params.filter(
  48. i =>
  49. !["require", "module", "exports"].includes(
  50. /** @type {Identifier} */ (i).name
  51. )
  52. ),
  53. () => {
  54. if (fnData.fn.body.type === "BlockStatement") {
  55. parser.walkStatement(fnData.fn.body);
  56. } else {
  57. parser.walkExpression(fnData.fn.body);
  58. }
  59. }
  60. );
  61. parser.walkExpressions(fnData.expressions);
  62. if (fnData.needThis === false) {
  63. bindThis = false;
  64. }
  65. } else {
  66. parser.walkExpression(expression);
  67. }
  68. return bindThis;
  69. }
  70. /**
  71. * @param {JavascriptParser} parser the parser
  72. * @returns {void}
  73. */
  74. apply(parser) {
  75. parser.hooks.call
  76. .for("require")
  77. .tap(
  78. "AMDRequireDependenciesBlockParserPlugin",
  79. this.processCallRequire.bind(this, parser)
  80. );
  81. }
  82. /**
  83. * @param {JavascriptParser} parser the parser
  84. * @param {CallExpression} expr call expression
  85. * @param {BasicEvaluatedExpression} param param
  86. * @returns {boolean | undefined} result
  87. */
  88. processArray(parser, expr, param) {
  89. if (param.isArray()) {
  90. for (const p of /** @type {BasicEvaluatedExpression[]} */ (param.items)) {
  91. const result = this.processItem(parser, expr, p);
  92. if (result === undefined) {
  93. this.processContext(parser, expr, p);
  94. }
  95. }
  96. return true;
  97. } else if (param.isConstArray()) {
  98. /** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
  99. const deps = [];
  100. for (const request of /** @type {EXPECTED_ANY[]} */ (param.array)) {
  101. let dep;
  102. let localModule;
  103. if (request === "require") {
  104. dep = RuntimeGlobals.require;
  105. } else if (["exports", "module"].includes(request)) {
  106. dep = request;
  107. } else if ((localModule = getLocalModule(parser.state, request))) {
  108. localModule.flagUsed();
  109. dep = new LocalModuleDependency(localModule, undefined, false);
  110. dep.loc = /** @type {DependencyLocation} */ (expr.loc);
  111. parser.state.module.addPresentationalDependency(dep);
  112. } else {
  113. dep = this.newRequireItemDependency(request);
  114. dep.loc = /** @type {DependencyLocation} */ (expr.loc);
  115. dep.optional = Boolean(parser.scope.inTry);
  116. parser.state.current.addDependency(dep);
  117. }
  118. deps.push(dep);
  119. }
  120. const dep = this.newRequireArrayDependency(
  121. deps,
  122. /** @type {Range} */ (param.range)
  123. );
  124. dep.loc = /** @type {DependencyLocation} */ (expr.loc);
  125. dep.optional = Boolean(parser.scope.inTry);
  126. parser.state.module.addPresentationalDependency(dep);
  127. return true;
  128. }
  129. }
  130. /**
  131. * @param {JavascriptParser} parser the parser
  132. * @param {CallExpression} expr call expression
  133. * @param {BasicEvaluatedExpression} param param
  134. * @returns {boolean | undefined} result
  135. */
  136. processItem(parser, expr, param) {
  137. if (param.isConditional()) {
  138. for (const p of /** @type {BasicEvaluatedExpression[]} */ (
  139. param.options
  140. )) {
  141. const result = this.processItem(parser, expr, p);
  142. if (result === undefined) {
  143. this.processContext(parser, expr, p);
  144. }
  145. }
  146. return true;
  147. } else if (param.isString()) {
  148. let dep;
  149. let localModule;
  150. if (param.string === "require") {
  151. dep = new ConstDependency(
  152. RuntimeGlobals.require,
  153. /** @type {TODO} */
  154. (param.string),
  155. [RuntimeGlobals.require]
  156. );
  157. } else if (param.string === "module") {
  158. dep = new ConstDependency(
  159. /** @type {string} */
  160. (
  161. /** @type {BuildInfo} */
  162. (parser.state.module.buildInfo).moduleArgument
  163. ),
  164. /** @type {Range} */ (param.range),
  165. [RuntimeGlobals.module]
  166. );
  167. } else if (param.string === "exports") {
  168. dep = new ConstDependency(
  169. /** @type {string} */
  170. (
  171. /** @type {BuildInfo} */
  172. (parser.state.module.buildInfo).exportsArgument
  173. ),
  174. /** @type {Range} */ (param.range),
  175. [RuntimeGlobals.exports]
  176. );
  177. } else if (
  178. (localModule = getLocalModule(
  179. parser.state,
  180. /** @type {string} */ (param.string)
  181. ))
  182. ) {
  183. localModule.flagUsed();
  184. dep = new LocalModuleDependency(localModule, param.range, false);
  185. } else {
  186. dep = this.newRequireItemDependency(
  187. /** @type {string} */ (param.string),
  188. param.range
  189. );
  190. dep.loc = /** @type {DependencyLocation} */ (expr.loc);
  191. dep.optional = Boolean(parser.scope.inTry);
  192. parser.state.current.addDependency(dep);
  193. return true;
  194. }
  195. dep.loc = /** @type {DependencyLocation} */ (expr.loc);
  196. parser.state.module.addPresentationalDependency(dep);
  197. return true;
  198. }
  199. }
  200. /**
  201. * @param {JavascriptParser} parser the parser
  202. * @param {CallExpression} expr call expression
  203. * @param {BasicEvaluatedExpression} param param
  204. * @returns {boolean | undefined} result
  205. */
  206. processContext(parser, expr, param) {
  207. const dep = ContextDependencyHelpers.create(
  208. AMDRequireContextDependency,
  209. /** @type {Range} */
  210. (param.range),
  211. param,
  212. expr,
  213. this.options,
  214. {
  215. category: "amd"
  216. },
  217. parser
  218. );
  219. if (!dep) return;
  220. dep.loc = /** @type {DependencyLocation} */ (expr.loc);
  221. dep.optional = Boolean(parser.scope.inTry);
  222. parser.state.current.addDependency(dep);
  223. return true;
  224. }
  225. /**
  226. * @param {BasicEvaluatedExpression} param param
  227. * @returns {string | undefined} result
  228. */
  229. processArrayForRequestString(param) {
  230. if (param.isArray()) {
  231. const result =
  232. /** @type {BasicEvaluatedExpression[]} */
  233. (param.items).map(item => this.processItemForRequestString(item));
  234. if (result.every(Boolean)) return result.join(" ");
  235. } else if (param.isConstArray()) {
  236. return /** @type {string[]} */ (param.array).join(" ");
  237. }
  238. }
  239. /**
  240. * @param {BasicEvaluatedExpression} param param
  241. * @returns {string | undefined} result
  242. */
  243. processItemForRequestString(param) {
  244. if (param.isConditional()) {
  245. const result =
  246. /** @type {BasicEvaluatedExpression[]} */
  247. (param.options).map(item => this.processItemForRequestString(item));
  248. if (result.every(Boolean)) return result.join("|");
  249. } else if (param.isString()) {
  250. return param.string;
  251. }
  252. }
  253. /**
  254. * @param {JavascriptParser} parser the parser
  255. * @param {CallExpression} expr call expression
  256. * @returns {boolean | undefined} result
  257. */
  258. processCallRequire(parser, expr) {
  259. /** @type {BasicEvaluatedExpression | undefined} */
  260. let param;
  261. /** @type {AMDRequireDependenciesBlock | undefined | null} */
  262. let depBlock;
  263. /** @type {AMDRequireDependency | undefined} */
  264. let dep;
  265. /** @type {boolean | undefined} */
  266. let result;
  267. const old = parser.state.current;
  268. if (expr.arguments.length >= 1) {
  269. param = parser.evaluateExpression(
  270. /** @type {Expression} */ (expr.arguments[0])
  271. );
  272. depBlock = this.newRequireDependenciesBlock(
  273. /** @type {DependencyLocation} */ (expr.loc),
  274. this.processArrayForRequestString(param)
  275. );
  276. dep = this.newRequireDependency(
  277. /** @type {Range} */ (expr.range),
  278. /** @type {Range} */ (param.range),
  279. expr.arguments.length > 1
  280. ? /** @type {Range} */ (expr.arguments[1].range)
  281. : null,
  282. expr.arguments.length > 2
  283. ? /** @type {Range} */ (expr.arguments[2].range)
  284. : null
  285. );
  286. dep.loc = /** @type {DependencyLocation} */ (expr.loc);
  287. depBlock.addDependency(dep);
  288. parser.state.current = /** @type {TODO} */ (depBlock);
  289. }
  290. if (expr.arguments.length === 1) {
  291. parser.inScope([], () => {
  292. result = this.processArray(
  293. parser,
  294. expr,
  295. /** @type {BasicEvaluatedExpression} */ (param)
  296. );
  297. });
  298. parser.state.current = old;
  299. if (!result) return;
  300. parser.state.current.addBlock(
  301. /** @type {AMDRequireDependenciesBlock} */ (depBlock)
  302. );
  303. return true;
  304. }
  305. if (expr.arguments.length === 2 || expr.arguments.length === 3) {
  306. try {
  307. parser.inScope([], () => {
  308. result = this.processArray(
  309. parser,
  310. expr,
  311. /** @type {BasicEvaluatedExpression} */ (param)
  312. );
  313. });
  314. if (!result) {
  315. const dep = new UnsupportedDependency(
  316. "unsupported",
  317. /** @type {Range} */ (expr.range)
  318. );
  319. old.addPresentationalDependency(dep);
  320. if (parser.state.module) {
  321. parser.state.module.addError(
  322. new UnsupportedFeatureWarning(
  323. `Cannot statically analyse 'require(…, …)' in line ${
  324. /** @type {SourceLocation} */ (expr.loc).start.line
  325. }`,
  326. /** @type {DependencyLocation} */ (expr.loc)
  327. )
  328. );
  329. }
  330. depBlock = null;
  331. return true;
  332. }
  333. /** @type {AMDRequireDependency} */
  334. (dep).functionBindThis = this.processFunctionArgument(
  335. parser,
  336. expr.arguments[1]
  337. );
  338. if (expr.arguments.length === 3) {
  339. /** @type {AMDRequireDependency} */
  340. (dep).errorCallbackBindThis = this.processFunctionArgument(
  341. parser,
  342. expr.arguments[2]
  343. );
  344. }
  345. } finally {
  346. parser.state.current = old;
  347. if (depBlock) parser.state.current.addBlock(depBlock);
  348. }
  349. return true;
  350. }
  351. }
  352. /**
  353. * @param {DependencyLocation} loc location
  354. * @param {string=} request request
  355. * @returns {AMDRequireDependenciesBlock} AMDRequireDependenciesBlock
  356. */
  357. newRequireDependenciesBlock(loc, request) {
  358. return new AMDRequireDependenciesBlock(loc, request);
  359. }
  360. /**
  361. * @param {Range} outerRange outer range
  362. * @param {Range} arrayRange array range
  363. * @param {Range | null} functionRange function range
  364. * @param {Range | null} errorCallbackRange error callback range
  365. * @returns {AMDRequireDependency} dependency
  366. */
  367. newRequireDependency(
  368. outerRange,
  369. arrayRange,
  370. functionRange,
  371. errorCallbackRange
  372. ) {
  373. return new AMDRequireDependency(
  374. outerRange,
  375. arrayRange,
  376. functionRange,
  377. errorCallbackRange
  378. );
  379. }
  380. /**
  381. * @param {string} request request
  382. * @param {Range=} range range
  383. * @returns {AMDRequireItemDependency} AMDRequireItemDependency
  384. */
  385. newRequireItemDependency(request, range) {
  386. return new AMDRequireItemDependency(request, range);
  387. }
  388. /**
  389. * @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
  390. * @param {Range} range range
  391. * @returns {AMDRequireArrayDependency} AMDRequireArrayDependency
  392. */
  393. newRequireArrayDependency(depsArray, range) {
  394. return new AMDRequireArrayDependency(depsArray, range);
  395. }
  396. }
  397. module.exports = AMDRequireDependenciesBlockParserPlugin;