/** * @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), ); } }, }); }, };