Skip to content

Commit de14d1c

Browse files
mdjermanovicmdjermanovic
authoredFeb 28, 2020
Fix: wrap-iife autofix removes mandatory parentheses (#12905)
·
v9.23.0v7.0.0-alpha.2
1 parent 5775b06 commit de14d1c

File tree

2 files changed

+460
-17
lines changed

2 files changed

+460
-17
lines changed
 

‎lib/rules/wrap-iife.js

+54-17
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,21 @@
1010
//------------------------------------------------------------------------------
1111

1212
const astUtils = require("./utils/ast-utils");
13+
const eslintUtils = require("eslint-utils");
14+
15+
//----------------------------------------------------------------------
16+
// Helpers
17+
//----------------------------------------------------------------------
18+
19+
/**
20+
* Check if the given node is callee of a `NewExpression` node
21+
* @param {ASTNode} node node to check
22+
* @returns {boolean} True if the node is callee of a `NewExpression` node
23+
* @private
24+
*/
25+
function isCalleeOfNewExpression(node) {
26+
return node.parent.type === "NewExpression" && node.parent.callee === node;
27+
}
1328

1429
//------------------------------------------------------------------------------
1530
// Rule Definition
@@ -58,15 +73,25 @@ module.exports = {
5873
const sourceCode = context.getSourceCode();
5974

6075
/**
61-
* Check if the node is wrapped in ()
76+
* Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()
6277
* @param {ASTNode} node node to evaluate
63-
* @returns {boolean} True if it is wrapped
78+
* @returns {boolean} True if it is wrapped in any parens
6479
* @private
6580
*/
66-
function wrapped(node) {
81+
function isWrappedInAnyParens(node) {
6782
return astUtils.isParenthesised(sourceCode, node);
6883
}
6984

85+
/**
86+
* Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count
87+
* @param {ASTNode} node node to evaluate
88+
* @returns {boolean} True if it is wrapped in grouping parens
89+
* @private
90+
*/
91+
function isWrappedInGroupingParens(node) {
92+
return eslintUtils.isParenthesized(1, node, sourceCode);
93+
}
94+
7095
/**
7196
* Get the function node from an IIFE
7297
* @param {ASTNode} node node to evaluate
@@ -99,10 +124,10 @@ module.exports = {
99124
return;
100125
}
101126

102-
const callExpressionWrapped = wrapped(node),
103-
functionExpressionWrapped = wrapped(innerNode);
127+
const isCallExpressionWrapped = isWrappedInAnyParens(node),
128+
isFunctionExpressionWrapped = isWrappedInAnyParens(innerNode);
104129

105-
if (!callExpressionWrapped && !functionExpressionWrapped) {
130+
if (!isCallExpressionWrapped && !isFunctionExpressionWrapped) {
106131
context.report({
107132
node,
108133
messageId: "wrapInvocation",
@@ -112,27 +137,39 @@ module.exports = {
112137
return fixer.replaceText(nodeToSurround, `(${sourceCode.getText(nodeToSurround)})`);
113138
}
114139
});
115-
} else if (style === "inside" && !functionExpressionWrapped) {
140+
} else if (style === "inside" && !isFunctionExpressionWrapped) {
116141
context.report({
117142
node,
118143
messageId: "wrapExpression",
119144
fix(fixer) {
120145

146+
// The outer call expression will always be wrapped at this point.
147+
148+
if (isWrappedInGroupingParens(node) && !isCalleeOfNewExpression(node)) {
149+
150+
/*
151+
* Parenthesize the function expression and remove unnecessary grouping parens around the call expression.
152+
* Replace the range between the end of the function expression and the end of the call expression.
153+
* for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
154+
*/
155+
156+
const parenAfter = sourceCode.getTokenAfter(node);
157+
158+
return fixer.replaceTextRange(
159+
[innerNode.range[1], parenAfter.range[1]],
160+
`)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`
161+
);
162+
}
163+
121164
/*
122-
* The outer call expression will always be wrapped at this point.
123-
* Replace the range between the end of the function expression and the end of the call expression.
124-
* for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
125-
* Replace the parens from the outer expression, and parenthesize the function expression.
165+
* Call expression is wrapped in mandatory parens such as if(), or in necessary grouping parens.
166+
* These parens cannot be removed, so just parenthesize the function expression.
126167
*/
127-
const parenAfter = sourceCode.getTokenAfter(node);
128168

129-
return fixer.replaceTextRange(
130-
[innerNode.range[1], parenAfter.range[1]],
131-
`)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`
132-
);
169+
return fixer.replaceText(innerNode, `(${sourceCode.getText(innerNode)})`);
133170
}
134171
});
135-
} else if (style === "outside" && !callExpressionWrapped) {
172+
} else if (style === "outside" && !isCallExpressionWrapped) {
136173
context.report({
137174
node,
138175
messageId: "moveInvocation",

‎tests/lib/rules/wrap-iife.js

+406
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,137 @@ ruleTester.run("wrap-iife", rule, {
6464
code: "var a = function(){return 1;};",
6565
options: ["any"]
6666
},
67+
{
68+
code: "var a = ((function(){return 1;})());", // always allows existing extra parens (parens both inside and outside)
69+
options: ["any"]
70+
},
71+
{
72+
code: "var a = ((function(){return 1;})());", // always allows existing extra parens (parens both inside and outside)
73+
options: ["inside"]
74+
},
75+
{
76+
code: "var a = ((function(){return 1;})());", // always allows existing extra parens (parens both inside and outside)
77+
options: ["outside"]
78+
},
79+
{
80+
code: "if (function (){}()) {}",
81+
options: ["any"]
82+
},
83+
{
84+
code: "while (function (){}()) {}",
85+
options: ["any"]
86+
},
87+
{
88+
code: "do {} while (function (){}())",
89+
options: ["any"]
90+
},
91+
{
92+
code: "switch (function (){}()) {}",
93+
options: ["any"]
94+
},
95+
{
96+
code: "with (function (){}()) {}",
97+
options: ["any"]
98+
},
99+
{
100+
code: "foo(function (){}());",
101+
options: ["any"]
102+
},
103+
{
104+
code: "new foo(function (){}());",
105+
options: ["any"]
106+
},
107+
{
108+
code: "import(function (){}());",
109+
options: ["any"],
110+
parserOptions: { ecmaVersion: 2020 }
111+
},
112+
{
113+
code: "if ((function (){})()) {}",
114+
options: ["any"]
115+
},
116+
{
117+
code: "while (((function (){})())) {}",
118+
options: ["any"]
119+
},
120+
{
121+
code: "if (function (){}()) {}",
122+
options: ["outside"]
123+
},
124+
{
125+
code: "while (function (){}()) {}",
126+
options: ["outside"]
127+
},
128+
{
129+
code: "do {} while (function (){}())",
130+
options: ["outside"]
131+
},
132+
{
133+
code: "switch (function (){}()) {}",
134+
options: ["outside"]
135+
},
136+
{
137+
code: "with (function (){}()) {}",
138+
options: ["outside"]
139+
},
140+
{
141+
code: "foo(function (){}());",
142+
options: ["outside"]
143+
},
144+
{
145+
code: "new foo(function (){}());",
146+
options: ["outside"]
147+
},
148+
{
149+
code: "import(function (){}());",
150+
options: ["outside"],
151+
parserOptions: { ecmaVersion: 2020 }
152+
},
153+
{
154+
code: "if ((function (){})()) {}",
155+
options: ["outside"]
156+
},
157+
{
158+
code: "while (((function (){})())) {}",
159+
options: ["outside"]
160+
},
161+
{
162+
code: "if ((function (){})()) {}",
163+
options: ["inside"]
164+
},
165+
{
166+
code: "while ((function (){})()) {}",
167+
options: ["inside"]
168+
},
169+
{
170+
code: "do {} while ((function (){})())",
171+
options: ["inside"]
172+
},
173+
{
174+
code: "switch ((function (){})()) {}",
175+
options: ["inside"]
176+
},
177+
{
178+
code: "with ((function (){})()) {}",
179+
options: ["inside"]
180+
},
181+
{
182+
code: "foo((function (){})());",
183+
options: ["inside"]
184+
},
185+
{
186+
code: "new foo((function (){})());",
187+
options: ["inside"]
188+
},
189+
{
190+
code: "import((function (){})());",
191+
options: ["inside"],
192+
parserOptions: { ecmaVersion: 2020 }
193+
},
194+
{
195+
code: "while (((function (){})())) {}",
196+
options: ["inside"]
197+
},
67198
{
68199
code: "window.bar = (function() { return 3; }.call(this, arg1));",
69200
options: ["outside", { functionPrototypeMethods: true }]
@@ -84,6 +215,10 @@ ruleTester.run("wrap-iife", rule, {
84215
code: "window.bar = function() { return 3; }.call(this, arg1);",
85216
options: ["inside"]
86217
},
218+
{
219+
code: "window.bar = function() { return 3; }.call(this, arg1);",
220+
options: ["inside", {}]
221+
},
87222
{
88223
code: "window.bar = function() { return 3; }.call(this, arg1);",
89224
options: ["inside", { functionPrototypeMethods: false }]
@@ -107,6 +242,137 @@ ruleTester.run("wrap-iife", rule, {
107242
{
108243
code: "var a = function(){return 1;}.bind(this).apply(that);",
109244
options: ["inside", { functionPrototypeMethods: true }]
245+
},
246+
{
247+
code: "var a = ((function(){return 1;}).call());", // always allows existing extra parens (parens both inside and outside)
248+
options: ["any", { functionPrototypeMethods: true }]
249+
},
250+
{
251+
code: "var a = ((function(){return 1;}).call());", // always allows existing extra parens (parens both inside and outside)
252+
options: ["inside", { functionPrototypeMethods: true }]
253+
},
254+
{
255+
code: "var a = ((function(){return 1;}).call());", // always allows existing extra parens (parens both inside and outside)
256+
options: ["outside", { functionPrototypeMethods: true }]
257+
},
258+
{
259+
code: "if (function (){}.call()) {}",
260+
options: ["any", { functionPrototypeMethods: true }]
261+
},
262+
{
263+
code: "while (function (){}.call()) {}",
264+
options: ["any", { functionPrototypeMethods: true }]
265+
},
266+
{
267+
code: "do {} while (function (){}.call())",
268+
options: ["any", { functionPrototypeMethods: true }]
269+
},
270+
{
271+
code: "switch (function (){}.call()) {}",
272+
options: ["any", { functionPrototypeMethods: true }]
273+
},
274+
{
275+
code: "with (function (){}.call()) {}",
276+
options: ["any", { functionPrototypeMethods: true }]
277+
},
278+
{
279+
code: "foo(function (){}.call())",
280+
options: ["any", { functionPrototypeMethods: true }]
281+
},
282+
{
283+
code: "new foo(function (){}.call())",
284+
options: ["any", { functionPrototypeMethods: true }]
285+
},
286+
{
287+
code: "import(function (){}.call())",
288+
options: ["any", { functionPrototypeMethods: true }],
289+
parserOptions: { ecmaVersion: 2020 }
290+
},
291+
{
292+
code: "if ((function (){}).call()) {}",
293+
options: ["any", { functionPrototypeMethods: true }]
294+
},
295+
{
296+
code: "while (((function (){}).call())) {}",
297+
options: ["any", { functionPrototypeMethods: true }]
298+
},
299+
{
300+
code: "if (function (){}.call()) {}",
301+
options: ["outside", { functionPrototypeMethods: true }]
302+
},
303+
{
304+
code: "while (function (){}.call()) {}",
305+
options: ["outside", { functionPrototypeMethods: true }]
306+
},
307+
{
308+
code: "do {} while (function (){}.call())",
309+
options: ["outside", { functionPrototypeMethods: true }]
310+
},
311+
{
312+
code: "switch (function (){}.call()) {}",
313+
options: ["outside", { functionPrototypeMethods: true }]
314+
},
315+
{
316+
code: "with (function (){}.call()) {}",
317+
options: ["outside", { functionPrototypeMethods: true }]
318+
},
319+
{
320+
code: "foo(function (){}.call())",
321+
options: ["outside", { functionPrototypeMethods: true }]
322+
},
323+
{
324+
code: "new foo(function (){}.call())",
325+
options: ["outside", { functionPrototypeMethods: true }]
326+
},
327+
{
328+
code: "import(function (){}.call())",
329+
options: ["outside", { functionPrototypeMethods: true }],
330+
parserOptions: { ecmaVersion: 2020 }
331+
},
332+
{
333+
code: "if ((function (){}).call()) {}",
334+
options: ["outside", { functionPrototypeMethods: true }]
335+
},
336+
{
337+
code: "while (((function (){}).call())) {}",
338+
options: ["outside", { functionPrototypeMethods: true }]
339+
},
340+
{
341+
code: "if ((function (){}).call()) {}",
342+
options: ["inside", { functionPrototypeMethods: true }]
343+
},
344+
{
345+
code: "while ((function (){}).call()) {}",
346+
options: ["inside", { functionPrototypeMethods: true }]
347+
},
348+
{
349+
code: "do {} while ((function (){}).call())",
350+
options: ["inside", { functionPrototypeMethods: true }]
351+
},
352+
{
353+
code: "switch ((function (){}).call()) {}",
354+
options: ["inside", { functionPrototypeMethods: true }]
355+
},
356+
{
357+
code: "with ((function (){}).call()) {}",
358+
options: ["inside", { functionPrototypeMethods: true }]
359+
},
360+
{
361+
code: "foo((function (){}).call())",
362+
options: ["inside", { functionPrototypeMethods: true }]
363+
},
364+
{
365+
code: "new foo((function (){}).call())",
366+
options: ["inside", { functionPrototypeMethods: true }]
367+
},
368+
{
369+
code: "import((function (){}).call())",
370+
options: ["inside", { functionPrototypeMethods: true }],
371+
parserOptions: { ecmaVersion: 2020 }
372+
},
373+
{
374+
code: "if (((function (){}).call())) {}",
375+
options: ["inside", { functionPrototypeMethods: true }]
110376
}
111377
],
112378
invalid: [
@@ -142,6 +408,79 @@ ruleTester.run("wrap-iife", rule, {
142408
options: ["inside"],
143409
errors: [wrapExpressionError]
144410
},
411+
{
412+
code: "new foo((function (){}()))",
413+
output: "new foo((function (){})())",
414+
options: ["inside"],
415+
errors: [wrapExpressionError]
416+
},
417+
{
418+
code: "new (function (){}())",
419+
output: "new ((function (){})())", // wrap function expression, but don't remove necessary grouping parens
420+
options: ["inside"],
421+
errors: [wrapExpressionError]
422+
},
423+
{
424+
code: "new (function (){}())()",
425+
output: "new ((function (){})())()", // wrap function expression, but don't remove necessary grouping parens
426+
options: ["inside"],
427+
errors: [wrapExpressionError]
428+
},
429+
{
430+
code: "if (function (){}()) {}",
431+
output: "if ((function (){})()) {}", // wrap function expression, but don't remove mandatory parens
432+
options: ["inside"],
433+
errors: [wrapExpressionError]
434+
},
435+
{
436+
code: "if ((function (){}())) {}",
437+
output: "if ((function (){})()) {}", // wrap function expression and remove unnecessary grouping parens aroung the call expression
438+
options: ["inside"],
439+
errors: [wrapExpressionError]
440+
},
441+
{
442+
code: "while (function (){}()) {}",
443+
output: "while ((function (){})()) {}", // wrap function expression, but don't remove mandatory parens
444+
options: ["inside"],
445+
errors: [wrapExpressionError]
446+
},
447+
{
448+
code: "do {} while (function (){}())",
449+
output: "do {} while ((function (){})())", // wrap function expression, but don't remove mandatory parens
450+
options: ["inside"],
451+
errors: [wrapExpressionError]
452+
},
453+
{
454+
code: "switch (function (){}()) {}",
455+
output: "switch ((function (){})()) {}", // wrap function expression, but don't remove mandatory parens
456+
options: ["inside"],
457+
errors: [wrapExpressionError]
458+
},
459+
{
460+
code: "with (function (){}()) {}",
461+
output: "with ((function (){})()) {}", // wrap function expression, but don't remove mandatory parens
462+
options: ["inside"],
463+
errors: [wrapExpressionError]
464+
},
465+
{
466+
code: "foo(function (){}())",
467+
output: "foo((function (){})())", // wrap function expression, but don't remove mandatory parens
468+
options: ["inside"],
469+
errors: [wrapExpressionError]
470+
},
471+
{
472+
code: "new foo(function (){}())",
473+
output: "new foo((function (){})())", // wrap function expression, but don't remove mandatory parens
474+
options: ["inside"],
475+
errors: [wrapExpressionError]
476+
},
477+
{
478+
code: "import(function (){}())",
479+
output: "import((function (){})())", // wrap function expression, but don't remove mandatory parens
480+
options: ["inside"],
481+
parserOptions: { ecmaVersion: 2020 },
482+
errors: [wrapExpressionError]
483+
},
145484
{
146485

147486
// Ensure all comments get preserved when autofixing.
@@ -197,6 +536,73 @@ ruleTester.run("wrap-iife", rule, {
197536
output: "window.bar = (function() { return 3; }.call(this, arg1));",
198537
options: ["outside", { functionPrototypeMethods: true }],
199538
errors: [moveInvocationError]
539+
},
540+
{
541+
code: "new (function (){}.call())",
542+
output: "new ((function (){}).call())", // wrap function expression, but don't remove necessary grouping parens
543+
options: ["inside", { functionPrototypeMethods: true }],
544+
errors: [wrapExpressionError]
545+
},
546+
{
547+
code: "new (function (){}.call())()",
548+
output: "new ((function (){}).call())()", // wrap function expression, but don't remove necessary grouping parens
549+
options: ["inside", { functionPrototypeMethods: true }],
550+
errors: [wrapExpressionError]
551+
},
552+
{
553+
code: "if (function (){}.call()) {}",
554+
output: "if ((function (){}).call()) {}", // wrap function expression, but don't remove mandatory parens
555+
options: ["inside", { functionPrototypeMethods: true }],
556+
errors: [wrapExpressionError]
557+
},
558+
{
559+
code: "if ((function (){}.call())) {}",
560+
output: "if ((function (){}).call()) {}", // wrap function expression and remove unnecessary grouping parens aroung the call expression
561+
options: ["inside", { functionPrototypeMethods: true }],
562+
errors: [wrapExpressionError]
563+
},
564+
{
565+
code: "while (function (){}.call()) {}",
566+
output: "while ((function (){}).call()) {}", // wrap function expression, but don't remove mandatory parens
567+
options: ["inside", { functionPrototypeMethods: true }],
568+
errors: [wrapExpressionError]
569+
},
570+
{
571+
code: "do {} while (function (){}.call())",
572+
output: "do {} while ((function (){}).call())", // wrap function expression, but don't remove mandatory parens
573+
options: ["inside", { functionPrototypeMethods: true }],
574+
errors: [wrapExpressionError]
575+
},
576+
{
577+
code: "switch (function (){}.call()) {}",
578+
output: "switch ((function (){}).call()) {}", // wrap function expression, but don't remove mandatory parens
579+
options: ["inside", { functionPrototypeMethods: true }],
580+
errors: [wrapExpressionError]
581+
},
582+
{
583+
code: "with (function (){}.call()) {}",
584+
output: "with ((function (){}).call()) {}", // wrap function expression, but don't remove mandatory parens
585+
options: ["inside", { functionPrototypeMethods: true }],
586+
errors: [wrapExpressionError]
587+
},
588+
{
589+
code: "foo(function (){}.call())",
590+
output: "foo((function (){}).call())", // wrap function expression, but don't remove mandatory parens
591+
options: ["inside", { functionPrototypeMethods: true }],
592+
errors: [wrapExpressionError]
593+
},
594+
{
595+
code: "new foo(function (){}.call())",
596+
output: "new foo((function (){}).call())", // wrap function expression, but don't remove mandatory parens
597+
options: ["inside", { functionPrototypeMethods: true }],
598+
errors: [wrapExpressionError]
599+
},
600+
{
601+
code: "import(function (){}.call())",
602+
output: "import((function (){}).call())", // wrap function expression, but don't remove mandatory parens
603+
options: ["inside", { functionPrototypeMethods: true }],
604+
parserOptions: { ecmaVersion: 2020 },
605+
errors: [wrapExpressionError]
200606
}
201607
]
202608
});

0 commit comments

Comments
 (0)
Please sign in to comment.