363 lines
11 KiB
JavaScript
363 lines
11 KiB
JavaScript
/**
|
|
* @fileoverview enforce consistent line breaks inside function parentheses
|
|
* @author Teddy Katz
|
|
* @deprecated in ESLint v8.53.0
|
|
*/
|
|
'use strict';
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const astUtils = require('./utils/ast-utils');
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
|
|
/** @type {import('../types').Rule.RuleModule} */
|
|
module.exports = {
|
|
meta: {
|
|
deprecated: {
|
|
message: 'Formatting rules are being moved out of ESLint core.',
|
|
url: 'https://eslint.org/blog/2023/10/deprecating-formatting-rules/',
|
|
deprecatedSince: '8.53.0',
|
|
availableUntil: '10.0.0',
|
|
replacedBy: [
|
|
{
|
|
message:
|
|
'ESLint Stylistic now maintains deprecated stylistic core rules.',
|
|
url: 'https://eslint.style/guide/migration',
|
|
plugin: {
|
|
name: '@stylistic/eslint-plugin-js',
|
|
url: 'https://eslint.style/packages/js',
|
|
},
|
|
rule: {
|
|
name: 'function-paren-newline',
|
|
url: 'https://eslint.style/rules/js/function-paren-newline',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
type: 'layout',
|
|
|
|
docs: {
|
|
description: 'Enforce consistent line breaks inside function parentheses',
|
|
recommended: false,
|
|
url: 'https://eslint.org/docs/latest/rules/function-paren-newline',
|
|
},
|
|
|
|
fixable: 'whitespace',
|
|
|
|
schema: [
|
|
{
|
|
oneOf: [
|
|
{
|
|
enum: [
|
|
'always',
|
|
'never',
|
|
'consistent',
|
|
'multiline',
|
|
'multiline-arguments',
|
|
],
|
|
},
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
minItems: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
|
|
messages: {
|
|
expectedBefore: "Expected newline before ')'.",
|
|
expectedAfter: "Expected newline after '('.",
|
|
expectedBetween: 'Expected newline between arguments/params.',
|
|
unexpectedBefore: "Unexpected newline before ')'.",
|
|
unexpectedAfter: "Unexpected newline after '('.",
|
|
},
|
|
},
|
|
|
|
create(context) {
|
|
const sourceCode = context.sourceCode;
|
|
const rawOption = context.options[0] || 'multiline';
|
|
const multilineOption = rawOption === 'multiline';
|
|
const multilineArgumentsOption = rawOption === 'multiline-arguments';
|
|
const consistentOption = rawOption === 'consistent';
|
|
let minItems;
|
|
|
|
if (typeof rawOption === 'object') {
|
|
minItems = rawOption.minItems;
|
|
} else if (rawOption === 'always') {
|
|
minItems = 0;
|
|
} else if (rawOption === 'never') {
|
|
minItems = Infinity;
|
|
} else {
|
|
minItems = null;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Helpers
|
|
//----------------------------------------------------------------------
|
|
|
|
/**
|
|
* Determines whether there should be newlines inside function parens
|
|
* @param {ASTNode[]} elements The arguments or parameters in the list
|
|
* @param {boolean} hasLeftNewline `true` if the left paren has a newline in the current code.
|
|
* @returns {boolean} `true` if there should be newlines inside the function parens
|
|
*/
|
|
function shouldHaveNewlines(elements, hasLeftNewline) {
|
|
if (multilineArgumentsOption && elements.length === 1) {
|
|
return hasLeftNewline;
|
|
}
|
|
if (multilineOption || multilineArgumentsOption) {
|
|
return elements.some(
|
|
(element, index) =>
|
|
index !== elements.length - 1 &&
|
|
element.loc.end.line !== elements[index + 1].loc.start.line
|
|
);
|
|
}
|
|
if (consistentOption) {
|
|
return hasLeftNewline;
|
|
}
|
|
return elements.length >= minItems;
|
|
}
|
|
|
|
/**
|
|
* Validates parens
|
|
* @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token
|
|
* @param {ASTNode[]} elements The arguments or parameters in the list
|
|
* @returns {void}
|
|
*/
|
|
function validateParens(parens, elements) {
|
|
const leftParen = parens.leftParen;
|
|
const rightParen = parens.rightParen;
|
|
const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);
|
|
const tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen);
|
|
const hasLeftNewline = !astUtils.isTokenOnSameLine(
|
|
leftParen,
|
|
tokenAfterLeftParen
|
|
);
|
|
const hasRightNewline = !astUtils.isTokenOnSameLine(
|
|
tokenBeforeRightParen,
|
|
rightParen
|
|
);
|
|
const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);
|
|
|
|
if (hasLeftNewline && !needsNewlines) {
|
|
context.report({
|
|
node: leftParen,
|
|
messageId: 'unexpectedAfter',
|
|
fix(fixer) {
|
|
return (
|
|
sourceCode
|
|
.getText()
|
|
.slice(leftParen.range[1], tokenAfterLeftParen.range[0])
|
|
.trim()
|
|
) ?
|
|
// If there is a comment between the ( and the first element, don't do a fix.
|
|
null
|
|
: fixer.removeRange([
|
|
leftParen.range[1],
|
|
tokenAfterLeftParen.range[0],
|
|
]);
|
|
},
|
|
});
|
|
} else if (!hasLeftNewline && needsNewlines) {
|
|
context.report({
|
|
node: leftParen,
|
|
messageId: 'expectedAfter',
|
|
fix: (fixer) => fixer.insertTextAfter(leftParen, '\n'),
|
|
});
|
|
}
|
|
|
|
if (hasRightNewline && !needsNewlines) {
|
|
context.report({
|
|
node: rightParen,
|
|
messageId: 'unexpectedBefore',
|
|
fix(fixer) {
|
|
return (
|
|
sourceCode
|
|
.getText()
|
|
.slice(tokenBeforeRightParen.range[1], rightParen.range[0])
|
|
.trim()
|
|
) ?
|
|
// If there is a comment between the last element and the ), don't do a fix.
|
|
null
|
|
: fixer.removeRange([
|
|
tokenBeforeRightParen.range[1],
|
|
rightParen.range[0],
|
|
]);
|
|
},
|
|
});
|
|
} else if (!hasRightNewline && needsNewlines) {
|
|
context.report({
|
|
node: rightParen,
|
|
messageId: 'expectedBefore',
|
|
fix: (fixer) => fixer.insertTextBefore(rightParen, '\n'),
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validates a list of arguments or parameters
|
|
* @param {Object} parens An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token
|
|
* @param {ASTNode[]} elements The arguments or parameters in the list
|
|
* @returns {void}
|
|
*/
|
|
function validateArguments(parens, elements) {
|
|
const leftParen = parens.leftParen;
|
|
const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);
|
|
const hasLeftNewline = !astUtils.isTokenOnSameLine(
|
|
leftParen,
|
|
tokenAfterLeftParen
|
|
);
|
|
const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);
|
|
|
|
for (let i = 0; i <= elements.length - 2; i++) {
|
|
const currentElement = elements[i];
|
|
const nextElement = elements[i + 1];
|
|
const hasNewLine =
|
|
currentElement.loc.end.line !== nextElement.loc.start.line;
|
|
|
|
if (!hasNewLine && needsNewlines) {
|
|
context.report({
|
|
node: currentElement,
|
|
messageId: 'expectedBetween',
|
|
fix: (fixer) => fixer.insertTextBefore(nextElement, '\n'),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the left paren and right paren tokens of a node.
|
|
* @param {ASTNode} node The node with parens
|
|
* @throws {TypeError} Unexpected node type.
|
|
* @returns {Object} An object with keys `leftParen` for the left paren token, and `rightParen` for the right paren token.
|
|
* Can also return `null` if an expression has no parens (e.g. a NewExpression with no arguments, or an ArrowFunctionExpression
|
|
* with a single parameter)
|
|
*/
|
|
function getParenTokens(node) {
|
|
switch (node.type) {
|
|
case 'NewExpression':
|
|
if (
|
|
!node.arguments.length &&
|
|
!(
|
|
astUtils.isOpeningParenToken(
|
|
sourceCode.getLastToken(node, { skip: 1 })
|
|
) &&
|
|
astUtils.isClosingParenToken(sourceCode.getLastToken(node)) &&
|
|
node.callee.range[1] < node.range[1]
|
|
)
|
|
) {
|
|
// If the NewExpression does not have parens (e.g. `new Foo`), return null.
|
|
return null;
|
|
}
|
|
|
|
// falls through
|
|
|
|
case 'CallExpression':
|
|
return {
|
|
leftParen: sourceCode.getTokenAfter(
|
|
node.callee,
|
|
astUtils.isOpeningParenToken
|
|
),
|
|
rightParen: sourceCode.getLastToken(node),
|
|
};
|
|
|
|
case 'FunctionDeclaration':
|
|
case 'FunctionExpression': {
|
|
const leftParen = sourceCode.getFirstToken(
|
|
node,
|
|
astUtils.isOpeningParenToken
|
|
);
|
|
const rightParen =
|
|
node.params.length ?
|
|
sourceCode.getTokenAfter(
|
|
node.params.at(-1),
|
|
astUtils.isClosingParenToken
|
|
)
|
|
: sourceCode.getTokenAfter(leftParen);
|
|
|
|
return { leftParen, rightParen };
|
|
}
|
|
|
|
case 'ArrowFunctionExpression': {
|
|
const firstToken = sourceCode.getFirstToken(node, {
|
|
skip: node.async ? 1 : 0,
|
|
});
|
|
|
|
if (!astUtils.isOpeningParenToken(firstToken)) {
|
|
// If the ArrowFunctionExpression has a single param without parens, return null.
|
|
return null;
|
|
}
|
|
|
|
const rightParen =
|
|
node.params.length ?
|
|
sourceCode.getTokenAfter(
|
|
node.params.at(-1),
|
|
astUtils.isClosingParenToken
|
|
)
|
|
: sourceCode.getTokenAfter(firstToken);
|
|
|
|
return {
|
|
leftParen: firstToken,
|
|
rightParen,
|
|
};
|
|
}
|
|
|
|
case 'ImportExpression': {
|
|
const leftParen = sourceCode.getFirstToken(node, 1);
|
|
const rightParen = sourceCode.getLastToken(node);
|
|
|
|
return { leftParen, rightParen };
|
|
}
|
|
|
|
default:
|
|
throw new TypeError(`unexpected node with type ${node.type}`);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Public
|
|
//----------------------------------------------------------------------
|
|
|
|
return {
|
|
[[
|
|
'ArrowFunctionExpression',
|
|
'CallExpression',
|
|
'FunctionDeclaration',
|
|
'FunctionExpression',
|
|
'ImportExpression',
|
|
'NewExpression',
|
|
]](node) {
|
|
const parens = getParenTokens(node);
|
|
let params;
|
|
|
|
if (node.type === 'ImportExpression') {
|
|
params = [node.source];
|
|
} else if (astUtils.isFunction(node)) {
|
|
params = node.params;
|
|
} else {
|
|
params = node.arguments;
|
|
}
|
|
|
|
if (parens) {
|
|
validateParens(parens, params);
|
|
|
|
if (multilineArgumentsOption) {
|
|
validateArguments(parens, params);
|
|
}
|
|
}
|
|
},
|
|
};
|
|
},
|
|
};
|