2218 lines
72 KiB
JavaScript
2218 lines
72 KiB
JavaScript
/**
|
|
* @fileoverview This rule sets a specific indentation style and width for your code
|
|
*
|
|
* @author Teddy Katz
|
|
* @author Vitaly Puzrin
|
|
* @author Gyandeep Singh
|
|
* @deprecated in ESLint v8.53.0
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const astUtils = require('./utils/ast-utils');
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Rule Definition
|
|
//------------------------------------------------------------------------------
|
|
|
|
const KNOWN_NODES = new Set([
|
|
'AssignmentExpression',
|
|
'AssignmentPattern',
|
|
'ArrayExpression',
|
|
'ArrayPattern',
|
|
'ArrowFunctionExpression',
|
|
'AwaitExpression',
|
|
'BlockStatement',
|
|
'BinaryExpression',
|
|
'BreakStatement',
|
|
'CallExpression',
|
|
'CatchClause',
|
|
'ChainExpression',
|
|
'ClassBody',
|
|
'ClassDeclaration',
|
|
'ClassExpression',
|
|
'ConditionalExpression',
|
|
'ContinueStatement',
|
|
'DoWhileStatement',
|
|
'DebuggerStatement',
|
|
'EmptyStatement',
|
|
'ExperimentalRestProperty',
|
|
'ExperimentalSpreadProperty',
|
|
'ExpressionStatement',
|
|
'ForStatement',
|
|
'ForInStatement',
|
|
'ForOfStatement',
|
|
'FunctionDeclaration',
|
|
'FunctionExpression',
|
|
'Identifier',
|
|
'IfStatement',
|
|
'Literal',
|
|
'LabeledStatement',
|
|
'LogicalExpression',
|
|
'MemberExpression',
|
|
'MetaProperty',
|
|
'MethodDefinition',
|
|
'NewExpression',
|
|
'ObjectExpression',
|
|
'ObjectPattern',
|
|
'PrivateIdentifier',
|
|
'Program',
|
|
'Property',
|
|
'PropertyDefinition',
|
|
'RestElement',
|
|
'ReturnStatement',
|
|
'SequenceExpression',
|
|
'SpreadElement',
|
|
'StaticBlock',
|
|
'Super',
|
|
'SwitchCase',
|
|
'SwitchStatement',
|
|
'TaggedTemplateExpression',
|
|
'TemplateElement',
|
|
'TemplateLiteral',
|
|
'ThisExpression',
|
|
'ThrowStatement',
|
|
'TryStatement',
|
|
'UnaryExpression',
|
|
'UpdateExpression',
|
|
'VariableDeclaration',
|
|
'VariableDeclarator',
|
|
'WhileStatement',
|
|
'WithStatement',
|
|
'YieldExpression',
|
|
'JSXFragment',
|
|
'JSXOpeningFragment',
|
|
'JSXClosingFragment',
|
|
'JSXIdentifier',
|
|
'JSXNamespacedName',
|
|
'JSXMemberExpression',
|
|
'JSXEmptyExpression',
|
|
'JSXExpressionContainer',
|
|
'JSXElement',
|
|
'JSXClosingElement',
|
|
'JSXOpeningElement',
|
|
'JSXAttribute',
|
|
'JSXSpreadAttribute',
|
|
'JSXText',
|
|
'ExportDefaultDeclaration',
|
|
'ExportNamedDeclaration',
|
|
'ExportAllDeclaration',
|
|
'ExportSpecifier',
|
|
'ImportDeclaration',
|
|
'ImportSpecifier',
|
|
'ImportDefaultSpecifier',
|
|
'ImportNamespaceSpecifier',
|
|
'ImportExpression',
|
|
]);
|
|
|
|
/*
|
|
* General rule strategy:
|
|
* 1. An OffsetStorage instance stores a map of desired offsets, where each token has a specified offset from another
|
|
* specified token or to the first column.
|
|
* 2. As the AST is traversed, modify the desired offsets of tokens accordingly. For example, when entering a
|
|
* BlockStatement, offset all of the tokens in the BlockStatement by 1 indent level from the opening curly
|
|
* brace of the BlockStatement.
|
|
* 3. After traversing the AST, calculate the expected indentation levels of every token according to the
|
|
* OffsetStorage container.
|
|
* 4. For each line, compare the expected indentation of the first token to the actual indentation in the file,
|
|
* and report the token if the two values are not equal.
|
|
*/
|
|
|
|
/**
|
|
* A mutable map that stores (key, value) pairs. The keys are numeric indices, and must be unique.
|
|
* This is intended to be a generic wrapper around a map with non-negative integer keys, so that the underlying implementation
|
|
* can easily be swapped out.
|
|
*/
|
|
class IndexMap {
|
|
/**
|
|
* Creates an empty map
|
|
* @param {number} maxKey The maximum key
|
|
*/
|
|
constructor(maxKey) {
|
|
// Initializing the array with the maximum expected size avoids dynamic reallocations that could degrade performance.
|
|
this._values = Array(maxKey + 1);
|
|
}
|
|
|
|
/**
|
|
* Inserts an entry into the map.
|
|
* @param {number} key The entry's key
|
|
* @param {any} value The entry's value
|
|
* @returns {void}
|
|
*/
|
|
insert(key, value) {
|
|
this._values[key] = value;
|
|
}
|
|
|
|
/**
|
|
* Finds the value of the entry with the largest key less than or equal to the provided key
|
|
* @param {number} key The provided key
|
|
* @returns {*|undefined} The value of the found entry, or undefined if no such entry exists.
|
|
*/
|
|
findLastNotAfter(key) {
|
|
const values = this._values;
|
|
|
|
for (let index = key; index >= 0; index--) {
|
|
const value = values[index];
|
|
|
|
if (value) {
|
|
return value;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
/**
|
|
* Deletes all of the keys in the interval [start, end)
|
|
* @param {number} start The start of the range
|
|
* @param {number} end The end of the range
|
|
* @returns {void}
|
|
*/
|
|
deleteRange(start, end) {
|
|
this._values.fill(void 0, start, end);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A helper class to get token-based info related to indentation
|
|
*/
|
|
class TokenInfo {
|
|
/**
|
|
* @param {SourceCode} sourceCode A SourceCode object
|
|
*/
|
|
constructor(sourceCode) {
|
|
this.sourceCode = sourceCode;
|
|
this.firstTokensByLineNumber = new Map();
|
|
const tokens = sourceCode.tokensAndComments;
|
|
|
|
for (let i = 0; i < tokens.length; i++) {
|
|
const token = tokens[i];
|
|
|
|
if (!this.firstTokensByLineNumber.has(token.loc.start.line)) {
|
|
this.firstTokensByLineNumber.set(token.loc.start.line, token);
|
|
}
|
|
if (
|
|
!this.firstTokensByLineNumber.has(token.loc.end.line) &&
|
|
sourceCode.text
|
|
.slice(token.range[1] - token.loc.end.column, token.range[1])
|
|
.trim()
|
|
) {
|
|
this.firstTokensByLineNumber.set(token.loc.end.line, token);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the first token on a given token's line
|
|
* @param {Token|ASTNode} token a node or token
|
|
* @returns {Token} The first token on the given line
|
|
*/
|
|
getFirstTokenOfLine(token) {
|
|
return this.firstTokensByLineNumber.get(token.loc.start.line);
|
|
}
|
|
|
|
/**
|
|
* Determines whether a token is the first token in its line
|
|
* @param {Token} token The token
|
|
* @returns {boolean} `true` if the token is the first on its line
|
|
*/
|
|
isFirstTokenOfLine(token) {
|
|
return this.getFirstTokenOfLine(token) === token;
|
|
}
|
|
|
|
/**
|
|
* Get the actual indent of a token
|
|
* @param {Token} token Token to examine. This should be the first token on its line.
|
|
* @returns {string} The indentation characters that precede the token
|
|
*/
|
|
getTokenIndent(token) {
|
|
return this.sourceCode.text.slice(
|
|
token.range[0] - token.loc.start.column,
|
|
token.range[0]
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A class to store information on desired offsets of tokens from each other
|
|
*/
|
|
class OffsetStorage {
|
|
/**
|
|
* @param {TokenInfo} tokenInfo a TokenInfo instance
|
|
* @param {number} indentSize The desired size of each indentation level
|
|
* @param {string} indentType The indentation character
|
|
* @param {number} maxIndex The maximum end index of any token
|
|
*/
|
|
constructor(tokenInfo, indentSize, indentType, maxIndex) {
|
|
this._tokenInfo = tokenInfo;
|
|
this._indentSize = indentSize;
|
|
this._indentType = indentType;
|
|
|
|
this._indexMap = new IndexMap(maxIndex);
|
|
this._indexMap.insert(0, { offset: 0, from: null, force: false });
|
|
|
|
this._lockedFirstTokens = new WeakMap();
|
|
this._desiredIndentCache = new WeakMap();
|
|
this._ignoredTokens = new WeakSet();
|
|
}
|
|
|
|
_getOffsetDescriptor(token) {
|
|
return this._indexMap.findLastNotAfter(token.range[0]);
|
|
}
|
|
|
|
/**
|
|
* Sets the offset column of token B to match the offset column of token A.
|
|
* - **WARNING**: This matches a *column*, even if baseToken is not the first token on its line. In
|
|
* most cases, `setDesiredOffset` should be used instead.
|
|
* @param {Token} baseToken The first token
|
|
* @param {Token} offsetToken The second token, whose offset should be matched to the first token
|
|
* @returns {void}
|
|
*/
|
|
matchOffsetOf(baseToken, offsetToken) {
|
|
/*
|
|
* lockedFirstTokens is a map from a token whose indentation is controlled by the "first" option to
|
|
* the token that it depends on. For example, with the `ArrayExpression: first` option, the first
|
|
* token of each element in the array after the first will be mapped to the first token of the first
|
|
* element. The desired indentation of each of these tokens is computed based on the desired indentation
|
|
* of the "first" element, rather than through the normal offset mechanism.
|
|
*/
|
|
this._lockedFirstTokens.set(offsetToken, baseToken);
|
|
}
|
|
|
|
/**
|
|
* Sets the desired offset of a token.
|
|
*
|
|
* This uses a line-based offset collapsing behavior to handle tokens on the same line.
|
|
* For example, consider the following two cases:
|
|
*
|
|
* (
|
|
* [
|
|
* bar
|
|
* ]
|
|
* )
|
|
*
|
|
* ([
|
|
* bar
|
|
* ])
|
|
*
|
|
* Based on the first case, it's clear that the `bar` token needs to have an offset of 1 indent level (4 spaces) from
|
|
* the `[` token, and the `[` token has to have an offset of 1 indent level from the `(` token. Since the `(` token is
|
|
* the first on its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2 indent levels (8 spaces)
|
|
* from the start of its line.
|
|
*
|
|
* However, in the second case `bar` should only be indented by 4 spaces. This is because the offset of 1 indent level
|
|
* between the `(` and the `[` tokens gets "collapsed" because the two tokens are on the same line. As a result, the
|
|
* `(` token is mapped to the `[` token with an offset of 0, and the rule correctly decides that `bar` should be indented
|
|
* by 1 indent level from the start of the line.
|
|
*
|
|
* This is useful because rule listeners can usually just call `setDesiredOffset` for all the tokens in the node,
|
|
* without needing to check which lines those tokens are on.
|
|
*
|
|
* Note that since collapsing only occurs when two tokens are on the same line, there are a few cases where non-intuitive
|
|
* behavior can occur. For example, consider the following cases:
|
|
*
|
|
* foo(
|
|
* ).
|
|
* bar(
|
|
* baz
|
|
* )
|
|
*
|
|
* foo(
|
|
* ).bar(
|
|
* baz
|
|
* )
|
|
*
|
|
* Based on the first example, it would seem that `bar` should be offset by 1 indent level from `foo`, and `baz`
|
|
* should be offset by 1 indent level from `bar`. However, this is not correct, because it would result in `baz`
|
|
* being indented by 2 indent levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines, no
|
|
* collapsing would occur).
|
|
*
|
|
* Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset `bar` by 1 level from the `)`, and
|
|
* offset the `)` by 0 levels from `foo`. This ensures that the offset between `bar` and the `)` are correctly collapsed
|
|
* in the second case.
|
|
* @param {Token} token The token
|
|
* @param {Token} fromToken The token that `token` should be offset from
|
|
* @param {number} offset The desired indent level
|
|
* @returns {void}
|
|
*/
|
|
setDesiredOffset(token, fromToken, offset) {
|
|
return this.setDesiredOffsets(token.range, fromToken, offset);
|
|
}
|
|
|
|
/**
|
|
* Sets the desired offset of all tokens in a range
|
|
* It's common for node listeners in this file to need to apply the same offset to a large, contiguous range of tokens.
|
|
* Moreover, the offset of any given token is usually updated multiple times (roughly once for each node that contains
|
|
* it). This means that the offset of each token is updated O(AST depth) times.
|
|
* It would not be performant to store and update the offsets for each token independently, because the rule would end
|
|
* up having a time complexity of O(number of tokens * AST depth), which is quite slow for large files.
|
|
*
|
|
* Instead, the offset tree is represented as a collection of contiguous offset ranges in a file. For example, the following
|
|
* list could represent the state of the offset tree at a given point:
|
|
*
|
|
* - Tokens starting in the interval [0, 15) are aligned with the beginning of the file
|
|
* - Tokens starting in the interval [15, 30) are offset by 1 indent level from the `bar` token
|
|
* - Tokens starting in the interval [30, 43) are offset by 1 indent level from the `foo` token
|
|
* - Tokens starting in the interval [43, 820) are offset by 2 indent levels from the `bar` token
|
|
* - Tokens starting in the interval [820, ∞) are offset by 1 indent level from the `baz` token
|
|
*
|
|
* The `setDesiredOffsets` methods inserts ranges like the ones above. The third line above would be inserted by using:
|
|
* `setDesiredOffsets([30, 43], fooToken, 1);`
|
|
* @param {[number, number]} range A [start, end] pair. All tokens with range[0] <= token.start < range[1] will have the offset applied.
|
|
* @param {Token} fromToken The token that this is offset from
|
|
* @param {number} offset The desired indent level
|
|
* @param {boolean} force `true` if this offset should not use the normal collapsing behavior. This should almost always be false.
|
|
* @returns {void}
|
|
*/
|
|
setDesiredOffsets(range, fromToken, offset, force) {
|
|
/*
|
|
* Offset ranges are stored as a collection of nodes, where each node maps a numeric key to an offset
|
|
* descriptor. The tree for the example above would have the following nodes:
|
|
*
|
|
* * key: 0, value: { offset: 0, from: null }
|
|
* * key: 15, value: { offset: 1, from: barToken }
|
|
* * key: 30, value: { offset: 1, from: fooToken }
|
|
* * key: 43, value: { offset: 2, from: barToken }
|
|
* * key: 820, value: { offset: 1, from: bazToken }
|
|
*
|
|
* To find the offset descriptor for any given token, one needs to find the node with the largest key
|
|
* which is <= token.start. To make this operation fast, the nodes are stored in a map indexed by key.
|
|
*/
|
|
|
|
const descriptorToInsert = { offset, from: fromToken, force };
|
|
|
|
const descriptorAfterRange = this._indexMap.findLastNotAfter(range[1]);
|
|
|
|
const fromTokenIsInRange =
|
|
fromToken &&
|
|
fromToken.range[0] >= range[0] &&
|
|
fromToken.range[1] <= range[1];
|
|
const fromTokenDescriptor =
|
|
fromTokenIsInRange && this._getOffsetDescriptor(fromToken);
|
|
|
|
// First, remove any existing nodes in the range from the map.
|
|
this._indexMap.deleteRange(range[0] + 1, range[1]);
|
|
|
|
// Insert a new node into the map for this range
|
|
this._indexMap.insert(range[0], descriptorToInsert);
|
|
|
|
/*
|
|
* To avoid circular offset dependencies, keep the `fromToken` token mapped to whatever it was mapped to previously,
|
|
* even if it's in the current range.
|
|
*/
|
|
if (fromTokenIsInRange) {
|
|
this._indexMap.insert(fromToken.range[0], fromTokenDescriptor);
|
|
this._indexMap.insert(fromToken.range[1], descriptorToInsert);
|
|
}
|
|
|
|
/*
|
|
* To avoid modifying the offset of tokens after the range, insert another node to keep the offset of the following
|
|
* tokens the same as it was before.
|
|
*/
|
|
this._indexMap.insert(range[1], descriptorAfterRange);
|
|
}
|
|
|
|
/**
|
|
* Gets the desired indent of a token
|
|
* @param {Token} token The token
|
|
* @returns {string} The desired indent of the token
|
|
*/
|
|
getDesiredIndent(token) {
|
|
if (!this._desiredIndentCache.has(token)) {
|
|
if (this._ignoredTokens.has(token)) {
|
|
/*
|
|
* If the token is ignored, use the actual indent of the token as the desired indent.
|
|
* This ensures that no errors are reported for this token.
|
|
*/
|
|
this._desiredIndentCache.set(
|
|
token,
|
|
this._tokenInfo.getTokenIndent(token)
|
|
);
|
|
} else if (this._lockedFirstTokens.has(token)) {
|
|
const firstToken = this._lockedFirstTokens.get(token);
|
|
|
|
this._desiredIndentCache.set(
|
|
token,
|
|
|
|
// (indentation for the first element's line)
|
|
this.getDesiredIndent(
|
|
this._tokenInfo.getFirstTokenOfLine(firstToken)
|
|
) +
|
|
// (space between the start of the first element's line and the first element)
|
|
this._indentType.repeat(
|
|
firstToken.loc.start.column -
|
|
this._tokenInfo.getFirstTokenOfLine(firstToken).loc.start.column
|
|
)
|
|
);
|
|
} else {
|
|
const offsetInfo = this._getOffsetDescriptor(token);
|
|
const offset =
|
|
(
|
|
offsetInfo.from &&
|
|
offsetInfo.from.loc.start.line === token.loc.start.line &&
|
|
!/^\s*?\n/u.test(token.value) &&
|
|
!offsetInfo.force
|
|
) ?
|
|
0
|
|
: offsetInfo.offset * this._indentSize;
|
|
|
|
this._desiredIndentCache.set(
|
|
token,
|
|
(offsetInfo.from ? this.getDesiredIndent(offsetInfo.from) : '') +
|
|
this._indentType.repeat(offset)
|
|
);
|
|
}
|
|
}
|
|
return this._desiredIndentCache.get(token);
|
|
}
|
|
|
|
/**
|
|
* Ignores a token, preventing it from being reported.
|
|
* @param {Token} token The token
|
|
* @returns {void}
|
|
*/
|
|
ignoreToken(token) {
|
|
if (this._tokenInfo.isFirstTokenOfLine(token)) {
|
|
this._ignoredTokens.add(token);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the first token that the given token's indentation is dependent on
|
|
* @param {Token} token The token
|
|
* @returns {Token} The token that the given token depends on, or `null` if the given token is at the top level
|
|
*/
|
|
getFirstDependency(token) {
|
|
return this._getOffsetDescriptor(token).from;
|
|
}
|
|
}
|
|
|
|
const ELEMENT_LIST_SCHEMA = {
|
|
oneOf: [
|
|
{
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
{
|
|
enum: ['first', 'off'],
|
|
},
|
|
],
|
|
};
|
|
|
|
/** @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: 'indent',
|
|
url: 'https://eslint.style/rules/js/indent',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
type: 'layout',
|
|
|
|
docs: {
|
|
description: 'Enforce consistent indentation',
|
|
recommended: false,
|
|
url: 'https://eslint.org/docs/latest/rules/indent',
|
|
},
|
|
|
|
fixable: 'whitespace',
|
|
|
|
schema: [
|
|
{
|
|
oneOf: [
|
|
{
|
|
enum: ['tab'],
|
|
},
|
|
{
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
SwitchCase: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
default: 0,
|
|
},
|
|
VariableDeclarator: {
|
|
oneOf: [
|
|
ELEMENT_LIST_SCHEMA,
|
|
{
|
|
type: 'object',
|
|
properties: {
|
|
var: ELEMENT_LIST_SCHEMA,
|
|
let: ELEMENT_LIST_SCHEMA,
|
|
const: ELEMENT_LIST_SCHEMA,
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
},
|
|
outerIIFEBody: {
|
|
oneOf: [
|
|
{
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
{
|
|
enum: ['off'],
|
|
},
|
|
],
|
|
},
|
|
MemberExpression: {
|
|
oneOf: [
|
|
{
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
{
|
|
enum: ['off'],
|
|
},
|
|
],
|
|
},
|
|
FunctionDeclaration: {
|
|
type: 'object',
|
|
properties: {
|
|
parameters: ELEMENT_LIST_SCHEMA,
|
|
body: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
FunctionExpression: {
|
|
type: 'object',
|
|
properties: {
|
|
parameters: ELEMENT_LIST_SCHEMA,
|
|
body: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
StaticBlock: {
|
|
type: 'object',
|
|
properties: {
|
|
body: {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
CallExpression: {
|
|
type: 'object',
|
|
properties: {
|
|
arguments: ELEMENT_LIST_SCHEMA,
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
ArrayExpression: ELEMENT_LIST_SCHEMA,
|
|
ObjectExpression: ELEMENT_LIST_SCHEMA,
|
|
ImportDeclaration: ELEMENT_LIST_SCHEMA,
|
|
flatTernaryExpressions: {
|
|
type: 'boolean',
|
|
default: false,
|
|
},
|
|
offsetTernaryExpressions: {
|
|
type: 'boolean',
|
|
default: false,
|
|
},
|
|
ignoredNodes: {
|
|
type: 'array',
|
|
items: {
|
|
type: 'string',
|
|
not: {
|
|
pattern: ':exit$',
|
|
},
|
|
},
|
|
},
|
|
ignoreComments: {
|
|
type: 'boolean',
|
|
default: false,
|
|
},
|
|
},
|
|
additionalProperties: false,
|
|
},
|
|
],
|
|
messages: {
|
|
wrongIndentation:
|
|
'Expected indentation of {{expected}} but found {{actual}}.',
|
|
},
|
|
},
|
|
|
|
create(context) {
|
|
const DEFAULT_VARIABLE_INDENT = 1;
|
|
const DEFAULT_PARAMETER_INDENT = 1;
|
|
const DEFAULT_FUNCTION_BODY_INDENT = 1;
|
|
|
|
let indentType = 'space';
|
|
let indentSize = 4;
|
|
const options = {
|
|
SwitchCase: 0,
|
|
VariableDeclarator: {
|
|
var: DEFAULT_VARIABLE_INDENT,
|
|
let: DEFAULT_VARIABLE_INDENT,
|
|
const: DEFAULT_VARIABLE_INDENT,
|
|
},
|
|
outerIIFEBody: 1,
|
|
FunctionDeclaration: {
|
|
parameters: DEFAULT_PARAMETER_INDENT,
|
|
body: DEFAULT_FUNCTION_BODY_INDENT,
|
|
},
|
|
FunctionExpression: {
|
|
parameters: DEFAULT_PARAMETER_INDENT,
|
|
body: DEFAULT_FUNCTION_BODY_INDENT,
|
|
},
|
|
StaticBlock: {
|
|
body: DEFAULT_FUNCTION_BODY_INDENT,
|
|
},
|
|
CallExpression: {
|
|
arguments: DEFAULT_PARAMETER_INDENT,
|
|
},
|
|
MemberExpression: 1,
|
|
ArrayExpression: 1,
|
|
ObjectExpression: 1,
|
|
ImportDeclaration: 1,
|
|
flatTernaryExpressions: false,
|
|
ignoredNodes: [],
|
|
ignoreComments: false,
|
|
};
|
|
|
|
if (context.options.length) {
|
|
if (context.options[0] === 'tab') {
|
|
indentSize = 1;
|
|
indentType = 'tab';
|
|
} else {
|
|
indentSize = context.options[0];
|
|
indentType = 'space';
|
|
}
|
|
|
|
if (context.options[1]) {
|
|
Object.assign(options, context.options[1]);
|
|
|
|
if (
|
|
typeof options.VariableDeclarator === 'number' ||
|
|
options.VariableDeclarator === 'first'
|
|
) {
|
|
options.VariableDeclarator = {
|
|
var: options.VariableDeclarator,
|
|
let: options.VariableDeclarator,
|
|
const: options.VariableDeclarator,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
const sourceCode = context.sourceCode;
|
|
const tokenInfo = new TokenInfo(sourceCode);
|
|
const offsets = new OffsetStorage(
|
|
tokenInfo,
|
|
indentSize,
|
|
indentType === 'space' ? ' ' : '\t',
|
|
sourceCode.text.length
|
|
);
|
|
const parameterParens = new WeakSet();
|
|
|
|
/**
|
|
* Creates an error message for a line, given the expected/actual indentation.
|
|
* @param {int} expectedAmount The expected amount of indentation characters for this line
|
|
* @param {int} actualSpaces The actual number of indentation spaces that were found on this line
|
|
* @param {int} actualTabs The actual number of indentation tabs that were found on this line
|
|
* @returns {string} An error message for this line
|
|
*/
|
|
function createErrorMessageData(expectedAmount, actualSpaces, actualTabs) {
|
|
const expectedStatement = `${expectedAmount} ${indentType}${expectedAmount === 1 ? '' : 's'}`; // e.g. "2 tabs"
|
|
const foundSpacesWord = `space${actualSpaces === 1 ? '' : 's'}`; // e.g. "space"
|
|
const foundTabsWord = `tab${actualTabs === 1 ? '' : 's'}`; // e.g. "tabs"
|
|
let foundStatement;
|
|
|
|
if (actualSpaces > 0) {
|
|
/*
|
|
* Abbreviate the message if the expected indentation is also spaces.
|
|
* e.g. 'Expected 4 spaces but found 2' rather than 'Expected 4 spaces but found 2 spaces'
|
|
*/
|
|
foundStatement =
|
|
indentType === 'space' ? actualSpaces : (
|
|
`${actualSpaces} ${foundSpacesWord}`
|
|
);
|
|
} else if (actualTabs > 0) {
|
|
foundStatement =
|
|
indentType === 'tab' ? actualTabs : `${actualTabs} ${foundTabsWord}`;
|
|
} else {
|
|
foundStatement = '0';
|
|
}
|
|
return {
|
|
expected: expectedStatement,
|
|
actual: foundStatement,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Reports a given indent violation
|
|
* @param {Token} token Token violating the indent rule
|
|
* @param {string} neededIndent Expected indentation string
|
|
* @returns {void}
|
|
*/
|
|
function report(token, neededIndent) {
|
|
const actualIndent = Array.from(tokenInfo.getTokenIndent(token));
|
|
const numSpaces = actualIndent.filter((char) => char === ' ').length;
|
|
const numTabs = actualIndent.filter((char) => char === '\t').length;
|
|
|
|
context.report({
|
|
node: token,
|
|
messageId: 'wrongIndentation',
|
|
data: createErrorMessageData(neededIndent.length, numSpaces, numTabs),
|
|
loc: {
|
|
start: { line: token.loc.start.line, column: 0 },
|
|
end: {
|
|
line: token.loc.start.line,
|
|
column: token.loc.start.column,
|
|
},
|
|
},
|
|
fix(fixer) {
|
|
const range = [
|
|
token.range[0] - token.loc.start.column,
|
|
token.range[0],
|
|
];
|
|
const newText = neededIndent;
|
|
|
|
return fixer.replaceTextRange(range, newText);
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks if a token's indentation is correct
|
|
* @param {Token} token Token to examine
|
|
* @param {string} desiredIndent Desired indentation of the string
|
|
* @returns {boolean} `true` if the token's indentation is correct
|
|
*/
|
|
function validateTokenIndent(token, desiredIndent) {
|
|
const indentation = tokenInfo.getTokenIndent(token);
|
|
|
|
return (
|
|
indentation === desiredIndent ||
|
|
// To avoid conflicts with no-mixed-spaces-and-tabs, don't report mixed spaces and tabs.
|
|
(indentation.includes(' ') && indentation.includes('\t'))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Check to see if the node is a file level IIFE
|
|
* @param {ASTNode} node The function node to check.
|
|
* @returns {boolean} True if the node is the outer IIFE
|
|
*/
|
|
function isOuterIIFE(node) {
|
|
/*
|
|
* Verify that the node is an IIFE
|
|
*/
|
|
if (
|
|
!node.parent ||
|
|
node.parent.type !== 'CallExpression' ||
|
|
node.parent.callee !== node
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Navigate legal ancestors to determine whether this IIFE is outer.
|
|
* A "legal ancestor" is an expression or statement that causes the function to get executed immediately.
|
|
* For example, `!(function(){})()` is an outer IIFE even though it is preceded by a ! operator.
|
|
*/
|
|
let statement = node.parent && node.parent.parent;
|
|
|
|
while (
|
|
(statement.type === 'UnaryExpression' &&
|
|
['!', '~', '+', '-'].includes(statement.operator)) ||
|
|
statement.type === 'AssignmentExpression' ||
|
|
statement.type === 'LogicalExpression' ||
|
|
statement.type === 'SequenceExpression' ||
|
|
statement.type === 'VariableDeclarator'
|
|
) {
|
|
statement = statement.parent;
|
|
}
|
|
|
|
return (
|
|
(statement.type === 'ExpressionStatement' ||
|
|
statement.type === 'VariableDeclaration') &&
|
|
statement.parent.type === 'Program'
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Counts the number of linebreaks that follow the last non-whitespace character in a string
|
|
* @param {string} string The string to check
|
|
* @returns {number} The number of JavaScript linebreaks that follow the last non-whitespace character,
|
|
* or the total number of linebreaks if the string is all whitespace.
|
|
*/
|
|
function countTrailingLinebreaks(string) {
|
|
const trailingWhitespace = string.match(/\s*$/u)[0];
|
|
const linebreakMatches = trailingWhitespace.match(
|
|
astUtils.createGlobalLinebreakMatcher()
|
|
);
|
|
|
|
return linebreakMatches === null ? 0 : linebreakMatches.length;
|
|
}
|
|
|
|
/**
|
|
* Check indentation for lists of elements (arrays, objects, function params)
|
|
* @param {ASTNode[]} elements List of elements that should be offset
|
|
* @param {Token} startToken The start token of the list that element should be aligned against, e.g. '['
|
|
* @param {Token} endToken The end token of the list, e.g. ']'
|
|
* @param {number|string} offset The amount that the elements should be offset
|
|
* @returns {void}
|
|
*/
|
|
function addElementListIndent(elements, startToken, endToken, offset) {
|
|
/**
|
|
* Gets the first token of a given element, including surrounding parentheses.
|
|
* @param {ASTNode} element A node in the `elements` list
|
|
* @returns {Token} The first token of this element
|
|
*/
|
|
function getFirstToken(element) {
|
|
let token = sourceCode.getTokenBefore(element);
|
|
|
|
while (astUtils.isOpeningParenToken(token) && token !== startToken) {
|
|
token = sourceCode.getTokenBefore(token);
|
|
}
|
|
return sourceCode.getTokenAfter(token);
|
|
}
|
|
|
|
// Run through all the tokens in the list, and offset them by one indent level (mainly for comments, other things will end up overridden)
|
|
offsets.setDesiredOffsets(
|
|
[startToken.range[1], endToken.range[0]],
|
|
startToken,
|
|
typeof offset === 'number' ? offset : 1
|
|
);
|
|
offsets.setDesiredOffset(endToken, startToken, 0);
|
|
|
|
// If the preference is "first" but there is no first element (e.g. sparse arrays w/ empty first slot), fall back to 1 level.
|
|
if (offset === 'first' && elements.length && !elements[0]) {
|
|
return;
|
|
}
|
|
elements.forEach((element, index) => {
|
|
if (!element) {
|
|
// Skip holes in arrays
|
|
return;
|
|
}
|
|
if (offset === 'off') {
|
|
// Ignore the first token of every element if the "off" option is used
|
|
offsets.ignoreToken(getFirstToken(element));
|
|
}
|
|
|
|
// Offset the following elements correctly relative to the first element
|
|
if (index === 0) {
|
|
return;
|
|
}
|
|
if (
|
|
offset === 'first' &&
|
|
tokenInfo.isFirstTokenOfLine(getFirstToken(element))
|
|
) {
|
|
offsets.matchOffsetOf(
|
|
getFirstToken(elements[0]),
|
|
getFirstToken(element)
|
|
);
|
|
} else {
|
|
const previousElement = elements[index - 1];
|
|
const firstTokenOfPreviousElement =
|
|
previousElement && getFirstToken(previousElement);
|
|
const previousElementLastToken =
|
|
previousElement && sourceCode.getLastToken(previousElement);
|
|
|
|
if (
|
|
previousElement &&
|
|
previousElementLastToken.loc.end.line -
|
|
countTrailingLinebreaks(previousElementLastToken.value) >
|
|
startToken.loc.end.line
|
|
) {
|
|
offsets.setDesiredOffsets(
|
|
[previousElement.range[1], element.range[1]],
|
|
firstTokenOfPreviousElement,
|
|
0
|
|
);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check and decide whether to check for indentation for blockless nodes
|
|
* Scenarios are for or while statements without braces around them
|
|
* @param {ASTNode} node node to examine
|
|
* @returns {void}
|
|
*/
|
|
function addBlocklessNodeIndent(node) {
|
|
if (node.type !== 'BlockStatement') {
|
|
const lastParentToken = sourceCode.getTokenBefore(
|
|
node,
|
|
astUtils.isNotOpeningParenToken
|
|
);
|
|
|
|
let firstBodyToken = sourceCode.getFirstToken(node);
|
|
let lastBodyToken = sourceCode.getLastToken(node);
|
|
|
|
while (
|
|
astUtils.isOpeningParenToken(
|
|
sourceCode.getTokenBefore(firstBodyToken)
|
|
) &&
|
|
astUtils.isClosingParenToken(sourceCode.getTokenAfter(lastBodyToken))
|
|
) {
|
|
firstBodyToken = sourceCode.getTokenBefore(firstBodyToken);
|
|
lastBodyToken = sourceCode.getTokenAfter(lastBodyToken);
|
|
}
|
|
|
|
offsets.setDesiredOffsets(
|
|
[firstBodyToken.range[0], lastBodyToken.range[1]],
|
|
lastParentToken,
|
|
1
|
|
);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks the indentation for nodes that are like function calls (`CallExpression` and `NewExpression`)
|
|
* @param {ASTNode} node A CallExpression or NewExpression node
|
|
* @returns {void}
|
|
*/
|
|
function addFunctionCallIndent(node) {
|
|
let openingParen;
|
|
|
|
if (node.arguments.length) {
|
|
openingParen = sourceCode.getFirstTokenBetween(
|
|
node.callee,
|
|
node.arguments[0],
|
|
astUtils.isOpeningParenToken
|
|
);
|
|
} else {
|
|
openingParen = sourceCode.getLastToken(node, 1);
|
|
}
|
|
const closingParen = sourceCode.getLastToken(node);
|
|
|
|
parameterParens.add(openingParen);
|
|
parameterParens.add(closingParen);
|
|
|
|
/*
|
|
* If `?.` token exists, set desired offset for that.
|
|
* This logic is copied from `MemberExpression`'s.
|
|
*/
|
|
if (node.optional) {
|
|
const dotToken = sourceCode.getTokenAfter(
|
|
node.callee,
|
|
astUtils.isQuestionDotToken
|
|
);
|
|
const calleeParenCount = sourceCode.getTokensBetween(
|
|
node.callee,
|
|
dotToken,
|
|
{ filter: astUtils.isClosingParenToken }
|
|
).length;
|
|
const firstTokenOfCallee =
|
|
calleeParenCount ?
|
|
sourceCode.getTokenBefore(node.callee, {
|
|
skip: calleeParenCount - 1,
|
|
})
|
|
: sourceCode.getFirstToken(node.callee);
|
|
const lastTokenOfCallee = sourceCode.getTokenBefore(dotToken);
|
|
const offsetBase =
|
|
lastTokenOfCallee.loc.end.line === openingParen.loc.start.line ?
|
|
lastTokenOfCallee
|
|
: firstTokenOfCallee;
|
|
|
|
offsets.setDesiredOffset(dotToken, offsetBase, 1);
|
|
}
|
|
|
|
const offsetAfterToken =
|
|
node.callee.type === 'TaggedTemplateExpression' ?
|
|
sourceCode.getFirstToken(node.callee.quasi)
|
|
: openingParen;
|
|
const offsetToken = sourceCode.getTokenBefore(offsetAfterToken);
|
|
|
|
offsets.setDesiredOffset(openingParen, offsetToken, 0);
|
|
|
|
addElementListIndent(
|
|
node.arguments,
|
|
openingParen,
|
|
closingParen,
|
|
options.CallExpression.arguments
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Checks the indentation of parenthesized values, given a list of tokens in a program
|
|
* @param {Token[]} tokens A list of tokens
|
|
* @returns {void}
|
|
*/
|
|
function addParensIndent(tokens) {
|
|
const parenStack = [];
|
|
const parenPairs = [];
|
|
|
|
for (let i = 0; i < tokens.length; i++) {
|
|
const nextToken = tokens[i];
|
|
|
|
if (astUtils.isOpeningParenToken(nextToken)) {
|
|
parenStack.push(nextToken);
|
|
} else if (astUtils.isClosingParenToken(nextToken)) {
|
|
parenPairs.push({
|
|
left: parenStack.pop(),
|
|
right: nextToken,
|
|
});
|
|
}
|
|
}
|
|
|
|
for (let i = parenPairs.length - 1; i >= 0; i--) {
|
|
const leftParen = parenPairs[i].left;
|
|
const rightParen = parenPairs[i].right;
|
|
|
|
// We only want to handle parens around expressions, so exclude parentheses that are in function parameters and function call arguments.
|
|
if (
|
|
!parameterParens.has(leftParen) &&
|
|
!parameterParens.has(rightParen)
|
|
) {
|
|
const parenthesizedTokens = new Set(
|
|
sourceCode.getTokensBetween(leftParen, rightParen)
|
|
);
|
|
|
|
parenthesizedTokens.forEach((token) => {
|
|
if (!parenthesizedTokens.has(offsets.getFirstDependency(token))) {
|
|
offsets.setDesiredOffset(token, leftParen, 1);
|
|
}
|
|
});
|
|
}
|
|
|
|
offsets.setDesiredOffset(rightParen, leftParen, 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ignore all tokens within an unknown node whose offset do not depend
|
|
* on another token's offset within the unknown node
|
|
* @param {ASTNode} node Unknown Node
|
|
* @returns {void}
|
|
*/
|
|
function ignoreNode(node) {
|
|
const unknownNodeTokens = new Set(
|
|
sourceCode.getTokens(node, { includeComments: true })
|
|
);
|
|
|
|
unknownNodeTokens.forEach((token) => {
|
|
if (!unknownNodeTokens.has(offsets.getFirstDependency(token))) {
|
|
const firstTokenOfLine = tokenInfo.getFirstTokenOfLine(token);
|
|
|
|
if (token === firstTokenOfLine) {
|
|
offsets.ignoreToken(token);
|
|
} else {
|
|
offsets.setDesiredOffset(token, firstTokenOfLine, 0);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Check whether the given token is on the first line of a statement.
|
|
* @param {Token} token The token to check.
|
|
* @param {ASTNode} leafNode The expression node that the token belongs directly.
|
|
* @returns {boolean} `true` if the token is on the first line of a statement.
|
|
*/
|
|
function isOnFirstLineOfStatement(token, leafNode) {
|
|
let node = leafNode;
|
|
|
|
while (
|
|
node.parent &&
|
|
!node.parent.type.endsWith('Statement') &&
|
|
!node.parent.type.endsWith('Declaration')
|
|
) {
|
|
node = node.parent;
|
|
}
|
|
node = node.parent;
|
|
|
|
return !node || node.loc.start.line === token.loc.start.line;
|
|
}
|
|
|
|
/**
|
|
* Check whether there are any blank (whitespace-only) lines between
|
|
* two tokens on separate lines.
|
|
* @param {Token} firstToken The first token.
|
|
* @param {Token} secondToken The second token.
|
|
* @returns {boolean} `true` if the tokens are on separate lines and
|
|
* there exists a blank line between them, `false` otherwise.
|
|
*/
|
|
function hasBlankLinesBetween(firstToken, secondToken) {
|
|
const firstTokenLine = firstToken.loc.end.line;
|
|
const secondTokenLine = secondToken.loc.start.line;
|
|
|
|
if (
|
|
firstTokenLine === secondTokenLine ||
|
|
firstTokenLine === secondTokenLine - 1
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
for (let line = firstTokenLine + 1; line < secondTokenLine; ++line) {
|
|
if (!tokenInfo.firstTokensByLineNumber.has(line)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const ignoredNodeFirstTokens = new Set();
|
|
|
|
const baseOffsetListeners = {
|
|
'ArrayExpression, ArrayPattern'(node) {
|
|
const openingBracket = sourceCode.getFirstToken(node);
|
|
const closingBracket = sourceCode.getTokenAfter(
|
|
[...node.elements].reverse().find((_) => _) || openingBracket,
|
|
astUtils.isClosingBracketToken
|
|
);
|
|
|
|
addElementListIndent(
|
|
node.elements,
|
|
openingBracket,
|
|
closingBracket,
|
|
options.ArrayExpression
|
|
);
|
|
},
|
|
|
|
'ObjectExpression, ObjectPattern'(node) {
|
|
const openingCurly = sourceCode.getFirstToken(node);
|
|
const closingCurly = sourceCode.getTokenAfter(
|
|
node.properties.length ? node.properties.at(-1) : openingCurly,
|
|
astUtils.isClosingBraceToken
|
|
);
|
|
|
|
addElementListIndent(
|
|
node.properties,
|
|
openingCurly,
|
|
closingCurly,
|
|
options.ObjectExpression
|
|
);
|
|
},
|
|
|
|
ArrowFunctionExpression(node) {
|
|
const maybeOpeningParen = sourceCode.getFirstToken(node, {
|
|
skip: node.async ? 1 : 0,
|
|
});
|
|
|
|
if (astUtils.isOpeningParenToken(maybeOpeningParen)) {
|
|
const openingParen = maybeOpeningParen;
|
|
const closingParen = sourceCode.getTokenBefore(
|
|
node.body,
|
|
astUtils.isClosingParenToken
|
|
);
|
|
|
|
parameterParens.add(openingParen);
|
|
parameterParens.add(closingParen);
|
|
addElementListIndent(
|
|
node.params,
|
|
openingParen,
|
|
closingParen,
|
|
options.FunctionExpression.parameters
|
|
);
|
|
}
|
|
|
|
addBlocklessNodeIndent(node.body);
|
|
},
|
|
|
|
AssignmentExpression(node) {
|
|
const operator = sourceCode.getFirstTokenBetween(
|
|
node.left,
|
|
node.right,
|
|
(token) => token.value === node.operator
|
|
);
|
|
|
|
offsets.setDesiredOffsets(
|
|
[operator.range[0], node.range[1]],
|
|
sourceCode.getLastToken(node.left),
|
|
1
|
|
);
|
|
offsets.ignoreToken(operator);
|
|
offsets.ignoreToken(sourceCode.getTokenAfter(operator));
|
|
},
|
|
|
|
'BinaryExpression, LogicalExpression'(node) {
|
|
const operator = sourceCode.getFirstTokenBetween(
|
|
node.left,
|
|
node.right,
|
|
(token) => token.value === node.operator
|
|
);
|
|
|
|
/*
|
|
* For backwards compatibility, don't check BinaryExpression indents, e.g.
|
|
* var foo = bar &&
|
|
* baz;
|
|
*/
|
|
|
|
const tokenAfterOperator = sourceCode.getTokenAfter(operator);
|
|
|
|
offsets.ignoreToken(operator);
|
|
offsets.ignoreToken(tokenAfterOperator);
|
|
offsets.setDesiredOffset(tokenAfterOperator, operator, 0);
|
|
},
|
|
|
|
'BlockStatement, ClassBody'(node) {
|
|
let blockIndentLevel;
|
|
|
|
if (node.parent && isOuterIIFE(node.parent)) {
|
|
blockIndentLevel = options.outerIIFEBody;
|
|
} else if (
|
|
node.parent &&
|
|
(node.parent.type === 'FunctionExpression' ||
|
|
node.parent.type === 'ArrowFunctionExpression')
|
|
) {
|
|
blockIndentLevel = options.FunctionExpression.body;
|
|
} else if (node.parent && node.parent.type === 'FunctionDeclaration') {
|
|
blockIndentLevel = options.FunctionDeclaration.body;
|
|
} else {
|
|
blockIndentLevel = 1;
|
|
}
|
|
|
|
/*
|
|
* For blocks that aren't lone statements, ensure that the opening curly brace
|
|
* is aligned with the parent.
|
|
*/
|
|
if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
|
|
offsets.setDesiredOffset(
|
|
sourceCode.getFirstToken(node),
|
|
sourceCode.getFirstToken(node.parent),
|
|
0
|
|
);
|
|
}
|
|
|
|
addElementListIndent(
|
|
node.body,
|
|
sourceCode.getFirstToken(node),
|
|
sourceCode.getLastToken(node),
|
|
blockIndentLevel
|
|
);
|
|
},
|
|
|
|
CallExpression: addFunctionCallIndent,
|
|
|
|
'ClassDeclaration[superClass], ClassExpression[superClass]'(node) {
|
|
const classToken = sourceCode.getFirstToken(node);
|
|
const extendsToken = sourceCode.getTokenBefore(
|
|
node.superClass,
|
|
astUtils.isNotOpeningParenToken
|
|
);
|
|
|
|
offsets.setDesiredOffsets(
|
|
[extendsToken.range[0], node.body.range[0]],
|
|
classToken,
|
|
1
|
|
);
|
|
},
|
|
|
|
ConditionalExpression(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
|
|
// `flatTernaryExpressions` option is for the following style:
|
|
// var a =
|
|
// foo > 0 ? bar :
|
|
// foo < 0 ? baz :
|
|
// /*else*/ qiz ;
|
|
if (
|
|
!options.flatTernaryExpressions ||
|
|
!astUtils.isTokenOnSameLine(node.test, node.consequent) ||
|
|
isOnFirstLineOfStatement(firstToken, node)
|
|
) {
|
|
const questionMarkToken = sourceCode.getFirstTokenBetween(
|
|
node.test,
|
|
node.consequent,
|
|
(token) => token.type === 'Punctuator' && token.value === '?'
|
|
);
|
|
const colonToken = sourceCode.getFirstTokenBetween(
|
|
node.consequent,
|
|
node.alternate,
|
|
(token) => token.type === 'Punctuator' && token.value === ':'
|
|
);
|
|
|
|
const firstConsequentToken =
|
|
sourceCode.getTokenAfter(questionMarkToken);
|
|
const lastConsequentToken = sourceCode.getTokenBefore(colonToken);
|
|
const firstAlternateToken = sourceCode.getTokenAfter(colonToken);
|
|
|
|
offsets.setDesiredOffset(questionMarkToken, firstToken, 1);
|
|
offsets.setDesiredOffset(colonToken, firstToken, 1);
|
|
|
|
offsets.setDesiredOffset(
|
|
firstConsequentToken,
|
|
firstToken,
|
|
(
|
|
firstConsequentToken.type === 'Punctuator' &&
|
|
options.offsetTernaryExpressions
|
|
) ?
|
|
2
|
|
: 1
|
|
);
|
|
|
|
/*
|
|
* The alternate and the consequent should usually have the same indentation.
|
|
* If they share part of a line, align the alternate against the first token of the consequent.
|
|
* This allows the alternate to be indented correctly in cases like this:
|
|
* foo ? (
|
|
* bar
|
|
* ) : ( // this '(' is aligned with the '(' above, so it's considered to be aligned with `foo`
|
|
* baz // as a result, `baz` is offset by 1 rather than 2
|
|
* )
|
|
*/
|
|
if (
|
|
lastConsequentToken.loc.end.line ===
|
|
firstAlternateToken.loc.start.line
|
|
) {
|
|
offsets.setDesiredOffset(
|
|
firstAlternateToken,
|
|
firstConsequentToken,
|
|
0
|
|
);
|
|
} else {
|
|
/**
|
|
* If the alternate and consequent do not share part of a line, offset the alternate from the first
|
|
* token of the conditional expression. For example:
|
|
* foo ? bar
|
|
* : baz
|
|
*
|
|
* If `baz` were aligned with `bar` rather than being offset by 1 from `foo`, `baz` would end up
|
|
* having no expected indentation.
|
|
*/
|
|
offsets.setDesiredOffset(
|
|
firstAlternateToken,
|
|
firstToken,
|
|
(
|
|
firstAlternateToken.type === 'Punctuator' &&
|
|
options.offsetTernaryExpressions
|
|
) ?
|
|
2
|
|
: 1
|
|
);
|
|
}
|
|
}
|
|
},
|
|
|
|
'DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement, WithStatement':
|
|
(node) => addBlocklessNodeIndent(node.body),
|
|
|
|
ExportNamedDeclaration(node) {
|
|
if (node.declaration === null) {
|
|
const closingCurly = sourceCode.getLastToken(
|
|
node,
|
|
astUtils.isClosingBraceToken
|
|
);
|
|
|
|
// Indent the specifiers in `export {foo, bar, baz}`
|
|
addElementListIndent(
|
|
node.specifiers,
|
|
sourceCode.getFirstToken(node, { skip: 1 }),
|
|
closingCurly,
|
|
1
|
|
);
|
|
|
|
if (node.source) {
|
|
// Indent everything after and including the `from` token in `export {foo, bar, baz} from 'qux'`
|
|
offsets.setDesiredOffsets(
|
|
[closingCurly.range[1], node.range[1]],
|
|
sourceCode.getFirstToken(node),
|
|
1
|
|
);
|
|
}
|
|
}
|
|
},
|
|
|
|
ForStatement(node) {
|
|
const forOpeningParen = sourceCode.getFirstToken(node, 1);
|
|
|
|
if (node.init) {
|
|
offsets.setDesiredOffsets(node.init.range, forOpeningParen, 1);
|
|
}
|
|
if (node.test) {
|
|
offsets.setDesiredOffsets(node.test.range, forOpeningParen, 1);
|
|
}
|
|
if (node.update) {
|
|
offsets.setDesiredOffsets(node.update.range, forOpeningParen, 1);
|
|
}
|
|
addBlocklessNodeIndent(node.body);
|
|
},
|
|
|
|
'FunctionDeclaration, FunctionExpression'(node) {
|
|
const closingParen = sourceCode.getTokenBefore(node.body);
|
|
const openingParen = sourceCode.getTokenBefore(
|
|
node.params.length ? node.params[0] : closingParen
|
|
);
|
|
|
|
parameterParens.add(openingParen);
|
|
parameterParens.add(closingParen);
|
|
addElementListIndent(
|
|
node.params,
|
|
openingParen,
|
|
closingParen,
|
|
options[node.type].parameters
|
|
);
|
|
},
|
|
|
|
IfStatement(node) {
|
|
addBlocklessNodeIndent(node.consequent);
|
|
if (node.alternate) {
|
|
addBlocklessNodeIndent(node.alternate);
|
|
}
|
|
},
|
|
|
|
/*
|
|
* For blockless nodes with semicolon-first style, don't indent the semicolon.
|
|
* e.g.
|
|
* if (foo)
|
|
* bar()
|
|
* ; [1, 2, 3].map(foo)
|
|
*
|
|
* Traversal into the node sets indentation of the semicolon, so we need to override it on exit.
|
|
*/
|
|
':matches(DoWhileStatement, ForStatement, ForInStatement, ForOfStatement, IfStatement, WhileStatement, WithStatement):exit'(
|
|
node
|
|
) {
|
|
let nodesToCheck;
|
|
|
|
if (node.type === 'IfStatement') {
|
|
nodesToCheck = [node.consequent];
|
|
if (node.alternate) {
|
|
nodesToCheck.push(node.alternate);
|
|
}
|
|
} else {
|
|
nodesToCheck = [node.body];
|
|
}
|
|
|
|
for (const nodeToCheck of nodesToCheck) {
|
|
const lastToken = sourceCode.getLastToken(nodeToCheck);
|
|
|
|
if (astUtils.isSemicolonToken(lastToken)) {
|
|
const tokenBeforeLast = sourceCode.getTokenBefore(lastToken);
|
|
const tokenAfterLast = sourceCode.getTokenAfter(lastToken);
|
|
|
|
// override indentation of `;` only if its line looks like a semicolon-first style line
|
|
if (
|
|
!astUtils.isTokenOnSameLine(tokenBeforeLast, lastToken) &&
|
|
tokenAfterLast &&
|
|
astUtils.isTokenOnSameLine(lastToken, tokenAfterLast)
|
|
) {
|
|
offsets.setDesiredOffset(
|
|
lastToken,
|
|
sourceCode.getFirstToken(node),
|
|
0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
ImportDeclaration(node) {
|
|
if (
|
|
node.specifiers.some(
|
|
(specifier) => specifier.type === 'ImportSpecifier'
|
|
)
|
|
) {
|
|
const openingCurly = sourceCode.getFirstToken(
|
|
node,
|
|
astUtils.isOpeningBraceToken
|
|
);
|
|
const closingCurly = sourceCode.getLastToken(
|
|
node,
|
|
astUtils.isClosingBraceToken
|
|
);
|
|
|
|
addElementListIndent(
|
|
node.specifiers.filter(
|
|
(specifier) => specifier.type === 'ImportSpecifier'
|
|
),
|
|
openingCurly,
|
|
closingCurly,
|
|
options.ImportDeclaration
|
|
);
|
|
}
|
|
|
|
const fromToken = sourceCode.getLastToken(
|
|
node,
|
|
(token) => token.type === 'Identifier' && token.value === 'from'
|
|
);
|
|
const sourceToken = sourceCode.getLastToken(
|
|
node,
|
|
(token) => token.type === 'String'
|
|
);
|
|
const semiToken = sourceCode.getLastToken(
|
|
node,
|
|
(token) => token.type === 'Punctuator' && token.value === ';'
|
|
);
|
|
|
|
if (fromToken) {
|
|
const end =
|
|
semiToken && semiToken.range[1] === sourceToken.range[1] ?
|
|
node.range[1]
|
|
: sourceToken.range[1];
|
|
|
|
offsets.setDesiredOffsets(
|
|
[fromToken.range[0], end],
|
|
sourceCode.getFirstToken(node),
|
|
1
|
|
);
|
|
}
|
|
},
|
|
|
|
ImportExpression(node) {
|
|
const openingParen = sourceCode.getFirstToken(node, 1);
|
|
const closingParen = sourceCode.getLastToken(node);
|
|
|
|
parameterParens.add(openingParen);
|
|
parameterParens.add(closingParen);
|
|
offsets.setDesiredOffset(
|
|
openingParen,
|
|
sourceCode.getTokenBefore(openingParen),
|
|
0
|
|
);
|
|
|
|
addElementListIndent(
|
|
[node.source],
|
|
openingParen,
|
|
closingParen,
|
|
options.CallExpression.arguments
|
|
);
|
|
},
|
|
|
|
'MemberExpression, JSXMemberExpression, MetaProperty'(node) {
|
|
const object = node.type === 'MetaProperty' ? node.meta : node.object;
|
|
const firstNonObjectToken = sourceCode.getFirstTokenBetween(
|
|
object,
|
|
node.property,
|
|
astUtils.isNotClosingParenToken
|
|
);
|
|
const secondNonObjectToken =
|
|
sourceCode.getTokenAfter(firstNonObjectToken);
|
|
|
|
const objectParenCount = sourceCode.getTokensBetween(
|
|
object,
|
|
node.property,
|
|
{ filter: astUtils.isClosingParenToken }
|
|
).length;
|
|
const firstObjectToken =
|
|
objectParenCount ?
|
|
sourceCode.getTokenBefore(object, {
|
|
skip: objectParenCount - 1,
|
|
})
|
|
: sourceCode.getFirstToken(object);
|
|
const lastObjectToken = sourceCode.getTokenBefore(firstNonObjectToken);
|
|
const firstPropertyToken =
|
|
node.computed ? firstNonObjectToken : secondNonObjectToken;
|
|
|
|
if (node.computed) {
|
|
// For computed MemberExpressions, match the closing bracket with the opening bracket.
|
|
offsets.setDesiredOffset(
|
|
sourceCode.getLastToken(node),
|
|
firstNonObjectToken,
|
|
0
|
|
);
|
|
offsets.setDesiredOffsets(
|
|
node.property.range,
|
|
firstNonObjectToken,
|
|
1
|
|
);
|
|
}
|
|
|
|
/*
|
|
* If the object ends on the same line that the property starts, match against the last token
|
|
* of the object, to ensure that the MemberExpression is not indented.
|
|
*
|
|
* Otherwise, match against the first token of the object, e.g.
|
|
* foo
|
|
* .bar
|
|
* .baz // <-- offset by 1 from `foo`
|
|
*/
|
|
const offsetBase =
|
|
lastObjectToken.loc.end.line === firstPropertyToken.loc.start.line ?
|
|
lastObjectToken
|
|
: firstObjectToken;
|
|
|
|
if (typeof options.MemberExpression === 'number') {
|
|
// Match the dot (for non-computed properties) or the opening bracket (for computed properties) against the object.
|
|
offsets.setDesiredOffset(
|
|
firstNonObjectToken,
|
|
offsetBase,
|
|
options.MemberExpression
|
|
);
|
|
|
|
/*
|
|
* For computed MemberExpressions, match the first token of the property against the opening bracket.
|
|
* Otherwise, match the first token of the property against the object.
|
|
*/
|
|
offsets.setDesiredOffset(
|
|
secondNonObjectToken,
|
|
node.computed ? firstNonObjectToken : offsetBase,
|
|
options.MemberExpression
|
|
);
|
|
} else {
|
|
// If the MemberExpression option is off, ignore the dot and the first token of the property.
|
|
offsets.ignoreToken(firstNonObjectToken);
|
|
offsets.ignoreToken(secondNonObjectToken);
|
|
|
|
// To ignore the property indentation, ensure that the property tokens depend on the ignored tokens.
|
|
offsets.setDesiredOffset(firstNonObjectToken, offsetBase, 0);
|
|
offsets.setDesiredOffset(
|
|
secondNonObjectToken,
|
|
firstNonObjectToken,
|
|
0
|
|
);
|
|
}
|
|
},
|
|
|
|
NewExpression(node) {
|
|
// Only indent the arguments if the NewExpression has parens (e.g. `new Foo(bar)` or `new Foo()`, but not `new Foo`
|
|
if (
|
|
node.arguments.length > 0 ||
|
|
(astUtils.isClosingParenToken(sourceCode.getLastToken(node)) &&
|
|
astUtils.isOpeningParenToken(sourceCode.getLastToken(node, 1)))
|
|
) {
|
|
addFunctionCallIndent(node);
|
|
}
|
|
},
|
|
|
|
Property(node) {
|
|
if (!node.shorthand && !node.method && node.kind === 'init') {
|
|
const colon = sourceCode.getFirstTokenBetween(
|
|
node.key,
|
|
node.value,
|
|
astUtils.isColonToken
|
|
);
|
|
|
|
offsets.ignoreToken(sourceCode.getTokenAfter(colon));
|
|
}
|
|
},
|
|
|
|
PropertyDefinition(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
const maybeSemicolonToken = sourceCode.getLastToken(node);
|
|
let keyLastToken;
|
|
|
|
// Indent key.
|
|
if (node.computed) {
|
|
const bracketTokenL = sourceCode.getTokenBefore(
|
|
node.key,
|
|
astUtils.isOpeningBracketToken
|
|
);
|
|
const bracketTokenR = (keyLastToken = sourceCode.getTokenAfter(
|
|
node.key,
|
|
astUtils.isClosingBracketToken
|
|
));
|
|
const keyRange = [bracketTokenL.range[1], bracketTokenR.range[0]];
|
|
|
|
if (bracketTokenL !== firstToken) {
|
|
offsets.setDesiredOffset(bracketTokenL, firstToken, 0);
|
|
}
|
|
offsets.setDesiredOffsets(keyRange, bracketTokenL, 1);
|
|
offsets.setDesiredOffset(bracketTokenR, bracketTokenL, 0);
|
|
} else {
|
|
const idToken = (keyLastToken = sourceCode.getFirstToken(node.key));
|
|
|
|
if (idToken !== firstToken) {
|
|
offsets.setDesiredOffset(idToken, firstToken, 1);
|
|
}
|
|
}
|
|
|
|
// Indent initializer.
|
|
if (node.value) {
|
|
const eqToken = sourceCode.getTokenBefore(
|
|
node.value,
|
|
astUtils.isEqToken
|
|
);
|
|
const valueToken = sourceCode.getTokenAfter(eqToken);
|
|
|
|
offsets.setDesiredOffset(eqToken, keyLastToken, 1);
|
|
offsets.setDesiredOffset(valueToken, eqToken, 1);
|
|
if (astUtils.isSemicolonToken(maybeSemicolonToken)) {
|
|
offsets.setDesiredOffset(maybeSemicolonToken, eqToken, 1);
|
|
}
|
|
} else if (astUtils.isSemicolonToken(maybeSemicolonToken)) {
|
|
offsets.setDesiredOffset(maybeSemicolonToken, keyLastToken, 1);
|
|
}
|
|
},
|
|
|
|
StaticBlock(node) {
|
|
const openingCurly = sourceCode.getFirstToken(node, {
|
|
skip: 1,
|
|
}); // skip the `static` token
|
|
const closingCurly = sourceCode.getLastToken(node);
|
|
|
|
addElementListIndent(
|
|
node.body,
|
|
openingCurly,
|
|
closingCurly,
|
|
options.StaticBlock.body
|
|
);
|
|
},
|
|
|
|
SwitchStatement(node) {
|
|
const openingCurly = sourceCode.getTokenAfter(
|
|
node.discriminant,
|
|
astUtils.isOpeningBraceToken
|
|
);
|
|
const closingCurly = sourceCode.getLastToken(node);
|
|
|
|
offsets.setDesiredOffsets(
|
|
[openingCurly.range[1], closingCurly.range[0]],
|
|
openingCurly,
|
|
options.SwitchCase
|
|
);
|
|
|
|
if (node.cases.length) {
|
|
sourceCode
|
|
.getTokensBetween(node.cases.at(-1), closingCurly, {
|
|
includeComments: true,
|
|
filter: astUtils.isCommentToken,
|
|
})
|
|
.forEach((token) => offsets.ignoreToken(token));
|
|
}
|
|
},
|
|
|
|
SwitchCase(node) {
|
|
if (
|
|
!(
|
|
node.consequent.length === 1 &&
|
|
node.consequent[0].type === 'BlockStatement'
|
|
)
|
|
) {
|
|
const caseKeyword = sourceCode.getFirstToken(node);
|
|
const tokenAfterCurrentCase = sourceCode.getTokenAfter(node);
|
|
|
|
offsets.setDesiredOffsets(
|
|
[caseKeyword.range[1], tokenAfterCurrentCase.range[0]],
|
|
caseKeyword,
|
|
1
|
|
);
|
|
}
|
|
},
|
|
|
|
TemplateLiteral(node) {
|
|
node.expressions.forEach((expression, index) => {
|
|
const previousQuasi = node.quasis[index];
|
|
const nextQuasi = node.quasis[index + 1];
|
|
const tokenToAlignFrom =
|
|
previousQuasi.loc.start.line === previousQuasi.loc.end.line ?
|
|
sourceCode.getFirstToken(previousQuasi)
|
|
: null;
|
|
|
|
offsets.setDesiredOffsets(
|
|
[previousQuasi.range[1], nextQuasi.range[0]],
|
|
tokenToAlignFrom,
|
|
1
|
|
);
|
|
offsets.setDesiredOffset(
|
|
sourceCode.getFirstToken(nextQuasi),
|
|
tokenToAlignFrom,
|
|
0
|
|
);
|
|
});
|
|
},
|
|
|
|
VariableDeclaration(node) {
|
|
let variableIndent =
|
|
Object.hasOwn(options.VariableDeclarator, node.kind) ?
|
|
options.VariableDeclarator[node.kind]
|
|
: DEFAULT_VARIABLE_INDENT;
|
|
|
|
const firstToken = sourceCode.getFirstToken(node),
|
|
lastToken = sourceCode.getLastToken(node);
|
|
|
|
if (options.VariableDeclarator[node.kind] === 'first') {
|
|
if (node.declarations.length > 1) {
|
|
addElementListIndent(
|
|
node.declarations,
|
|
firstToken,
|
|
lastToken,
|
|
'first'
|
|
);
|
|
return;
|
|
}
|
|
|
|
variableIndent = DEFAULT_VARIABLE_INDENT;
|
|
}
|
|
|
|
if (node.declarations.at(-1).loc.start.line > node.loc.start.line) {
|
|
/*
|
|
* VariableDeclarator indentation is a bit different from other forms of indentation, in that the
|
|
* indentation of an opening bracket sometimes won't match that of a closing bracket. For example,
|
|
* the following indentations are correct:
|
|
*
|
|
* var foo = {
|
|
* ok: true
|
|
* };
|
|
*
|
|
* var foo = {
|
|
* ok: true,
|
|
* },
|
|
* bar = 1;
|
|
*
|
|
* Account for when exiting the AST (after indentations have already been set for the nodes in
|
|
* the declaration) by manually increasing the indentation level of the tokens in this declarator
|
|
* on the same line as the start of the declaration, provided that there are declarators that
|
|
* follow this one.
|
|
*/
|
|
offsets.setDesiredOffsets(
|
|
node.range,
|
|
firstToken,
|
|
variableIndent,
|
|
true
|
|
);
|
|
} else {
|
|
offsets.setDesiredOffsets(node.range, firstToken, variableIndent);
|
|
}
|
|
|
|
if (astUtils.isSemicolonToken(lastToken)) {
|
|
offsets.ignoreToken(lastToken);
|
|
}
|
|
},
|
|
|
|
VariableDeclarator(node) {
|
|
if (node.init) {
|
|
const equalOperator = sourceCode.getTokenBefore(
|
|
node.init,
|
|
astUtils.isNotOpeningParenToken
|
|
);
|
|
const tokenAfterOperator = sourceCode.getTokenAfter(equalOperator);
|
|
|
|
offsets.ignoreToken(equalOperator);
|
|
offsets.ignoreToken(tokenAfterOperator);
|
|
offsets.setDesiredOffsets(
|
|
[tokenAfterOperator.range[0], node.range[1]],
|
|
equalOperator,
|
|
1
|
|
);
|
|
offsets.setDesiredOffset(
|
|
equalOperator,
|
|
sourceCode.getLastToken(node.id),
|
|
0
|
|
);
|
|
}
|
|
},
|
|
|
|
'JSXAttribute[value]'(node) {
|
|
const equalsToken = sourceCode.getFirstTokenBetween(
|
|
node.name,
|
|
node.value,
|
|
(token) => token.type === 'Punctuator' && token.value === '='
|
|
);
|
|
|
|
offsets.setDesiredOffsets(
|
|
[equalsToken.range[0], node.value.range[1]],
|
|
sourceCode.getFirstToken(node.name),
|
|
1
|
|
);
|
|
},
|
|
|
|
JSXElement(node) {
|
|
if (node.closingElement) {
|
|
addElementListIndent(
|
|
node.children,
|
|
sourceCode.getFirstToken(node.openingElement),
|
|
sourceCode.getFirstToken(node.closingElement),
|
|
1
|
|
);
|
|
}
|
|
},
|
|
|
|
JSXOpeningElement(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
let closingToken;
|
|
|
|
if (node.selfClosing) {
|
|
closingToken = sourceCode.getLastToken(node, { skip: 1 });
|
|
offsets.setDesiredOffset(
|
|
sourceCode.getLastToken(node),
|
|
closingToken,
|
|
0
|
|
);
|
|
} else {
|
|
closingToken = sourceCode.getLastToken(node);
|
|
}
|
|
offsets.setDesiredOffsets(
|
|
node.name.range,
|
|
sourceCode.getFirstToken(node)
|
|
);
|
|
addElementListIndent(node.attributes, firstToken, closingToken, 1);
|
|
},
|
|
|
|
JSXClosingElement(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
|
|
offsets.setDesiredOffsets(node.name.range, firstToken, 1);
|
|
},
|
|
|
|
JSXFragment(node) {
|
|
const firstOpeningToken = sourceCode.getFirstToken(
|
|
node.openingFragment
|
|
);
|
|
const firstClosingToken = sourceCode.getFirstToken(
|
|
node.closingFragment
|
|
);
|
|
|
|
addElementListIndent(
|
|
node.children,
|
|
firstOpeningToken,
|
|
firstClosingToken,
|
|
1
|
|
);
|
|
},
|
|
|
|
JSXOpeningFragment(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
const closingToken = sourceCode.getLastToken(node);
|
|
|
|
offsets.setDesiredOffsets(node.range, firstToken, 1);
|
|
offsets.matchOffsetOf(firstToken, closingToken);
|
|
},
|
|
|
|
JSXClosingFragment(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
const slashToken = sourceCode.getLastToken(node, { skip: 1 });
|
|
const closingToken = sourceCode.getLastToken(node);
|
|
const tokenToMatch =
|
|
astUtils.isTokenOnSameLine(slashToken, closingToken) ? slashToken : (
|
|
closingToken
|
|
);
|
|
|
|
offsets.setDesiredOffsets(node.range, firstToken, 1);
|
|
offsets.matchOffsetOf(firstToken, tokenToMatch);
|
|
},
|
|
|
|
JSXExpressionContainer(node) {
|
|
const openingCurly = sourceCode.getFirstToken(node);
|
|
const closingCurly = sourceCode.getLastToken(node);
|
|
|
|
offsets.setDesiredOffsets(
|
|
[openingCurly.range[1], closingCurly.range[0]],
|
|
openingCurly,
|
|
1
|
|
);
|
|
},
|
|
|
|
JSXSpreadAttribute(node) {
|
|
const openingCurly = sourceCode.getFirstToken(node);
|
|
const closingCurly = sourceCode.getLastToken(node);
|
|
|
|
offsets.setDesiredOffsets(
|
|
[openingCurly.range[1], closingCurly.range[0]],
|
|
openingCurly,
|
|
1
|
|
);
|
|
},
|
|
|
|
'*'(node) {
|
|
const firstToken = sourceCode.getFirstToken(node);
|
|
|
|
// Ensure that the children of every node are indented at least as much as the first token.
|
|
if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) {
|
|
offsets.setDesiredOffsets(node.range, firstToken, 0);
|
|
}
|
|
},
|
|
};
|
|
|
|
const listenerCallQueue = [];
|
|
|
|
/*
|
|
* To ignore the indentation of a node:
|
|
* 1. Don't call the node's listener when entering it (if it has a listener)
|
|
* 2. Don't set any offsets against the first token of the node.
|
|
* 3. Call `ignoreNode` on the node sometime after exiting it and before validating offsets.
|
|
*/
|
|
const offsetListeners = {};
|
|
|
|
for (const [selector, listener] of Object.entries(baseOffsetListeners)) {
|
|
/*
|
|
* Offset listener calls are deferred until traversal is finished, and are called as
|
|
* part of the final `Program:exit` listener. This is necessary because a node might
|
|
* be matched by multiple selectors.
|
|
*
|
|
* Example: Suppose there is an offset listener for `Identifier`, and the user has
|
|
* specified in configuration that `MemberExpression > Identifier` should be ignored.
|
|
* Due to selector specificity rules, the `Identifier` listener will get called first. However,
|
|
* if a given Identifier node is supposed to be ignored, then the `Identifier` offset listener
|
|
* should not have been called at all. Without doing extra selector matching, we don't know
|
|
* whether the Identifier matches the `MemberExpression > Identifier` selector until the
|
|
* `MemberExpression > Identifier` listener is called.
|
|
*
|
|
* To avoid this, the `Identifier` listener isn't called until traversal finishes and all
|
|
* ignored nodes are known.
|
|
*/
|
|
offsetListeners[selector] = (node) =>
|
|
listenerCallQueue.push({ listener, node });
|
|
}
|
|
|
|
// For each ignored node selector, set up a listener to collect it into the `ignoredNodes` set.
|
|
const ignoredNodes = new Set();
|
|
|
|
/**
|
|
* Ignores a node
|
|
* @param {ASTNode} node The node to ignore
|
|
* @returns {void}
|
|
*/
|
|
function addToIgnoredNodes(node) {
|
|
ignoredNodes.add(node);
|
|
ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node));
|
|
}
|
|
|
|
const ignoredNodeListeners = options.ignoredNodes.reduce(
|
|
(listeners, ignoredSelector) =>
|
|
Object.assign(listeners, {
|
|
[ignoredSelector]: addToIgnoredNodes,
|
|
}),
|
|
{}
|
|
);
|
|
|
|
/*
|
|
* Join the listeners, and add a listener to verify that all tokens actually have the correct indentation
|
|
* at the end.
|
|
*
|
|
* Using Object.assign will cause some offset listeners to be overwritten if the same selector also appears
|
|
* in `ignoredNodeListeners`. This isn't a problem because all of the matching nodes will be ignored,
|
|
* so those listeners wouldn't be called anyway.
|
|
*/
|
|
return Object.assign(offsetListeners, ignoredNodeListeners, {
|
|
'*:exit'(node) {
|
|
// If a node's type is nonstandard, we can't tell how its children should be offset, so ignore it.
|
|
if (!KNOWN_NODES.has(node.type)) {
|
|
addToIgnoredNodes(node);
|
|
}
|
|
},
|
|
'Program:exit'() {
|
|
// If ignoreComments option is enabled, ignore all comment tokens.
|
|
if (options.ignoreComments) {
|
|
sourceCode
|
|
.getAllComments()
|
|
.forEach((comment) => offsets.ignoreToken(comment));
|
|
}
|
|
|
|
// Invoke the queued offset listeners for the nodes that aren't ignored.
|
|
for (let i = 0; i < listenerCallQueue.length; i++) {
|
|
const nodeInfo = listenerCallQueue[i];
|
|
|
|
if (!ignoredNodes.has(nodeInfo.node)) {
|
|
nodeInfo.listener(nodeInfo.node);
|
|
}
|
|
}
|
|
|
|
// Update the offsets for ignored nodes to prevent their child tokens from being reported.
|
|
ignoredNodes.forEach(ignoreNode);
|
|
|
|
addParensIndent(sourceCode.ast.tokens);
|
|
|
|
/*
|
|
* Create a Map from (tokenOrComment) => (precedingToken).
|
|
* This is necessary because sourceCode.getTokenBefore does not handle a comment as an argument correctly.
|
|
*/
|
|
const precedingTokens = new WeakMap();
|
|
|
|
for (let i = 0; i < sourceCode.ast.comments.length; i++) {
|
|
const comment = sourceCode.ast.comments[i];
|
|
|
|
const tokenOrCommentBefore = sourceCode.getTokenBefore(comment, {
|
|
includeComments: true,
|
|
});
|
|
const hasToken =
|
|
precedingTokens.has(tokenOrCommentBefore) ?
|
|
precedingTokens.get(tokenOrCommentBefore)
|
|
: tokenOrCommentBefore;
|
|
|
|
precedingTokens.set(comment, hasToken);
|
|
}
|
|
|
|
for (let i = 1; i < sourceCode.lines.length + 1; i++) {
|
|
if (!tokenInfo.firstTokensByLineNumber.has(i)) {
|
|
// Don't check indentation on blank lines
|
|
continue;
|
|
}
|
|
|
|
const firstTokenOfLine = tokenInfo.firstTokensByLineNumber.get(i);
|
|
|
|
if (firstTokenOfLine.loc.start.line !== i) {
|
|
// Don't check the indentation of multi-line tokens (e.g. template literals or block comments) twice.
|
|
continue;
|
|
}
|
|
|
|
if (astUtils.isCommentToken(firstTokenOfLine)) {
|
|
const tokenBefore = precedingTokens.get(firstTokenOfLine);
|
|
const tokenAfter =
|
|
tokenBefore ?
|
|
sourceCode.getTokenAfter(tokenBefore)
|
|
: sourceCode.ast.tokens[0];
|
|
const mayAlignWithBefore =
|
|
tokenBefore &&
|
|
!hasBlankLinesBetween(tokenBefore, firstTokenOfLine);
|
|
const mayAlignWithAfter =
|
|
tokenAfter && !hasBlankLinesBetween(firstTokenOfLine, tokenAfter);
|
|
|
|
/*
|
|
* If a comment precedes a line that begins with a semicolon token, align to that token, i.e.
|
|
*
|
|
* let foo
|
|
* // comment
|
|
* ;(async () => {})()
|
|
*/
|
|
if (
|
|
tokenAfter &&
|
|
astUtils.isSemicolonToken(tokenAfter) &&
|
|
!astUtils.isTokenOnSameLine(firstTokenOfLine, tokenAfter)
|
|
) {
|
|
offsets.setDesiredOffset(firstTokenOfLine, tokenAfter, 0);
|
|
}
|
|
|
|
// If a comment matches the expected indentation of the token immediately before or after, don't report it.
|
|
if (
|
|
(mayAlignWithBefore &&
|
|
validateTokenIndent(
|
|
firstTokenOfLine,
|
|
offsets.getDesiredIndent(tokenBefore)
|
|
)) ||
|
|
(mayAlignWithAfter &&
|
|
validateTokenIndent(
|
|
firstTokenOfLine,
|
|
offsets.getDesiredIndent(tokenAfter)
|
|
))
|
|
) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// If the token matches the expected indentation, don't report it.
|
|
if (
|
|
validateTokenIndent(
|
|
firstTokenOfLine,
|
|
offsets.getDesiredIndent(firstTokenOfLine)
|
|
)
|
|
) {
|
|
continue;
|
|
}
|
|
|
|
// Otherwise, report the token/comment.
|
|
report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine));
|
|
}
|
|
},
|
|
});
|
|
},
|
|
};
|