1 |
|
2 |
|
3 |
|
4 |
|
5 | "use strict";
|
6 |
|
7 |
|
8 |
|
9 |
|
10 |
|
11 | const astUtils = require("./utils/ast-utils");
|
12 |
|
13 |
|
14 |
|
15 |
|
16 |
|
17 | module.exports = {
|
18 | meta: {
|
19 | type: "layout",
|
20 |
|
21 | docs: {
|
22 | description: "enforce consistent line breaks inside function parentheses",
|
23 | category: "Stylistic Issues",
|
24 | recommended: false,
|
25 | url: "https://eslint.org/docs/rules/function-paren-newline"
|
26 | },
|
27 |
|
28 | fixable: "whitespace",
|
29 |
|
30 | schema: [
|
31 | {
|
32 | oneOf: [
|
33 | {
|
34 | enum: ["always", "never", "consistent", "multiline", "multiline-arguments"]
|
35 | },
|
36 | {
|
37 | type: "object",
|
38 | properties: {
|
39 | minItems: {
|
40 | type: "integer",
|
41 | minimum: 0
|
42 | }
|
43 | },
|
44 | additionalProperties: false
|
45 | }
|
46 | ]
|
47 | }
|
48 | ],
|
49 |
|
50 | messages: {
|
51 | expectedBefore: "Expected newline before ')'.",
|
52 | expectedAfter: "Expected newline after '('.",
|
53 | expectedBetween: "Expected newline between arguments/params.",
|
54 | unexpectedBefore: "Unexpected newline before ')'.",
|
55 | unexpectedAfter: "Unexpected newline after '('."
|
56 | }
|
57 | },
|
58 |
|
59 | create(context) {
|
60 | const sourceCode = context.getSourceCode();
|
61 | const rawOption = context.options[0] || "multiline";
|
62 | const multilineOption = rawOption === "multiline";
|
63 | const multilineArgumentsOption = rawOption === "multiline-arguments";
|
64 | const consistentOption = rawOption === "consistent";
|
65 | let minItems;
|
66 |
|
67 | if (typeof rawOption === "object") {
|
68 | minItems = rawOption.minItems;
|
69 | } else if (rawOption === "always") {
|
70 | minItems = 0;
|
71 | } else if (rawOption === "never") {
|
72 | minItems = Infinity;
|
73 | } else {
|
74 | minItems = null;
|
75 | }
|
76 |
|
77 |
|
78 |
|
79 |
|
80 |
|
81 | |
82 |
|
83 |
|
84 |
|
85 |
|
86 |
|
87 | function shouldHaveNewlines(elements, hasLeftNewline) {
|
88 | if (multilineArgumentsOption && elements.length === 1) {
|
89 | return hasLeftNewline;
|
90 | }
|
91 | if (multilineOption || multilineArgumentsOption) {
|
92 | return elements.some((element, index) => index !== elements.length - 1 && element.loc.end.line !== elements[index + 1].loc.start.line);
|
93 | }
|
94 | if (consistentOption) {
|
95 | return hasLeftNewline;
|
96 | }
|
97 | return elements.length >= minItems;
|
98 | }
|
99 |
|
100 | |
101 |
|
102 |
|
103 |
|
104 |
|
105 |
|
106 | function validateParens(parens, elements) {
|
107 | const leftParen = parens.leftParen;
|
108 | const rightParen = parens.rightParen;
|
109 | const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);
|
110 | const tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen);
|
111 | const hasLeftNewline = !astUtils.isTokenOnSameLine(leftParen, tokenAfterLeftParen);
|
112 | const hasRightNewline = !astUtils.isTokenOnSameLine(tokenBeforeRightParen, rightParen);
|
113 | const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);
|
114 |
|
115 | if (hasLeftNewline && !needsNewlines) {
|
116 | context.report({
|
117 | node: leftParen,
|
118 | messageId: "unexpectedAfter",
|
119 | fix(fixer) {
|
120 | return sourceCode.getText().slice(leftParen.range[1], tokenAfterLeftParen.range[0]).trim()
|
121 |
|
122 |
|
123 | ? null
|
124 | : fixer.removeRange([leftParen.range[1], tokenAfterLeftParen.range[0]]);
|
125 | }
|
126 | });
|
127 | } else if (!hasLeftNewline && needsNewlines) {
|
128 | context.report({
|
129 | node: leftParen,
|
130 | messageId: "expectedAfter",
|
131 | fix: fixer => fixer.insertTextAfter(leftParen, "\n")
|
132 | });
|
133 | }
|
134 |
|
135 | if (hasRightNewline && !needsNewlines) {
|
136 | context.report({
|
137 | node: rightParen,
|
138 | messageId: "unexpectedBefore",
|
139 | fix(fixer) {
|
140 | return sourceCode.getText().slice(tokenBeforeRightParen.range[1], rightParen.range[0]).trim()
|
141 |
|
142 |
|
143 | ? null
|
144 | : fixer.removeRange([tokenBeforeRightParen.range[1], rightParen.range[0]]);
|
145 | }
|
146 | });
|
147 | } else if (!hasRightNewline && needsNewlines) {
|
148 | context.report({
|
149 | node: rightParen,
|
150 | messageId: "expectedBefore",
|
151 | fix: fixer => fixer.insertTextBefore(rightParen, "\n")
|
152 | });
|
153 | }
|
154 | }
|
155 |
|
156 | |
157 |
|
158 |
|
159 |
|
160 |
|
161 |
|
162 | function validateArguments(parens, elements) {
|
163 | const leftParen = parens.leftParen;
|
164 | const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);
|
165 | const hasLeftNewline = !astUtils.isTokenOnSameLine(leftParen, tokenAfterLeftParen);
|
166 | const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);
|
167 |
|
168 | for (let i = 0; i <= elements.length - 2; i++) {
|
169 | const currentElement = elements[i];
|
170 | const nextElement = elements[i + 1];
|
171 | const hasNewLine = currentElement.loc.end.line !== nextElement.loc.start.line;
|
172 |
|
173 | if (!hasNewLine && needsNewlines) {
|
174 | context.report({
|
175 | node: currentElement,
|
176 | messageId: "expectedBetween",
|
177 | fix: fixer => fixer.insertTextBefore(nextElement, "\n")
|
178 | });
|
179 | }
|
180 | }
|
181 | }
|
182 |
|
183 | |
184 |
|
185 |
|
186 |
|
187 |
|
188 |
|
189 |
|
190 | function getParenTokens(node) {
|
191 | switch (node.type) {
|
192 | case "NewExpression":
|
193 | if (!node.arguments.length && !(
|
194 | astUtils.isOpeningParenToken(sourceCode.getLastToken(node, { skip: 1 })) &&
|
195 | astUtils.isClosingParenToken(sourceCode.getLastToken(node))
|
196 | )) {
|
197 |
|
198 |
|
199 | return null;
|
200 | }
|
201 |
|
202 |
|
203 |
|
204 | case "CallExpression":
|
205 | return {
|
206 | leftParen: sourceCode.getTokenAfter(node.callee, astUtils.isOpeningParenToken),
|
207 | rightParen: sourceCode.getLastToken(node)
|
208 | };
|
209 |
|
210 | case "FunctionDeclaration":
|
211 | case "FunctionExpression": {
|
212 | const leftParen = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
|
213 | const rightParen = node.params.length
|
214 | ? sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils.isClosingParenToken)
|
215 | : sourceCode.getTokenAfter(leftParen);
|
216 |
|
217 | return { leftParen, rightParen };
|
218 | }
|
219 |
|
220 | case "ArrowFunctionExpression": {
|
221 | const firstToken = sourceCode.getFirstToken(node, { skip: (node.async ? 1 : 0) });
|
222 |
|
223 | if (!astUtils.isOpeningParenToken(firstToken)) {
|
224 |
|
225 |
|
226 | return null;
|
227 | }
|
228 |
|
229 | return {
|
230 | leftParen: firstToken,
|
231 | rightParen: sourceCode.getTokenBefore(node.body, astUtils.isClosingParenToken)
|
232 | };
|
233 | }
|
234 |
|
235 | case "ImportExpression": {
|
236 | const leftParen = sourceCode.getFirstToken(node, 1);
|
237 | const rightParen = sourceCode.getLastToken(node);
|
238 |
|
239 | return { leftParen, rightParen };
|
240 | }
|
241 |
|
242 | default:
|
243 | throw new TypeError(`unexpected node with type ${node.type}`);
|
244 | }
|
245 | }
|
246 |
|
247 |
|
248 |
|
249 |
|
250 |
|
251 | return {
|
252 | [[
|
253 | "ArrowFunctionExpression",
|
254 | "CallExpression",
|
255 | "FunctionDeclaration",
|
256 | "FunctionExpression",
|
257 | "ImportExpression",
|
258 | "NewExpression"
|
259 | ]](node) {
|
260 | const parens = getParenTokens(node);
|
261 | let params;
|
262 |
|
263 | if (node.type === "ImportExpression") {
|
264 | params = [node.source];
|
265 | } else if (astUtils.isFunction(node)) {
|
266 | params = node.params;
|
267 | } else {
|
268 | params = node.arguments;
|
269 | }
|
270 |
|
271 | if (parens) {
|
272 | validateParens(parens, params);
|
273 |
|
274 | if (multilineArgumentsOption) {
|
275 | validateArguments(parens, params);
|
276 | }
|
277 | }
|
278 | }
|
279 | };
|
280 | }
|
281 | };
|