no-sequences.js
4.66 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/**
* @fileoverview Rule to flag use of comma operator
* @author Brandon Mills
*/
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Helpers
//------------------------------------------------------------------------------
const DEFAULT_OPTIONS = {
allowInParentheses: true
};
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/** @type {import('../shared/types').Rule} */
module.exports = {
meta: {
type: "suggestion",
docs: {
description: "Disallow comma operators",
recommended: false,
url: "https://eslint.org/docs/rules/no-sequences"
},
schema: [{
properties: {
allowInParentheses: {
type: "boolean",
default: true
}
},
additionalProperties: false
}],
messages: {
unexpectedCommaExpression: "Unexpected use of comma operator."
}
},
create(context) {
const options = Object.assign({}, DEFAULT_OPTIONS, context.options[0]);
const sourceCode = context.getSourceCode();
/**
* Parts of the grammar that are required to have parens.
*/
const parenthesized = {
DoWhileStatement: "test",
IfStatement: "test",
SwitchStatement: "discriminant",
WhileStatement: "test",
WithStatement: "object",
ArrowFunctionExpression: "body"
/*
* Omitting CallExpression - commas are parsed as argument separators
* Omitting NewExpression - commas are parsed as argument separators
* Omitting ForInStatement - parts aren't individually parenthesised
* Omitting ForStatement - parts aren't individually parenthesised
*/
};
/**
* Determines whether a node is required by the grammar to be wrapped in
* parens, e.g. the test of an if statement.
* @param {ASTNode} node The AST node
* @returns {boolean} True if parens around node belong to parent node.
*/
function requiresExtraParens(node) {
return node.parent && parenthesized[node.parent.type] &&
node === node.parent[parenthesized[node.parent.type]];
}
/**
* Check if a node is wrapped in parens.
* @param {ASTNode} node The AST node
* @returns {boolean} True if the node has a paren on each side.
*/
function isParenthesised(node) {
return astUtils.isParenthesised(sourceCode, node);
}
/**
* Check if a node is wrapped in two levels of parens.
* @param {ASTNode} node The AST node
* @returns {boolean} True if two parens surround the node on each side.
*/
function isParenthesisedTwice(node) {
const previousToken = sourceCode.getTokenBefore(node, 1),
nextToken = sourceCode.getTokenAfter(node, 1);
return isParenthesised(node) && previousToken && nextToken &&
astUtils.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] &&
astUtils.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];
}
return {
SequenceExpression(node) {
// Always allow sequences in for statement update
if (node.parent.type === "ForStatement" &&
(node === node.parent.init || node === node.parent.update)) {
return;
}
// Wrapping a sequence in extra parens indicates intent
if (options.allowInParentheses) {
if (requiresExtraParens(node)) {
if (isParenthesisedTwice(node)) {
return;
}
} else {
if (isParenthesised(node)) {
return;
}
}
}
const firstCommaToken = sourceCode.getTokenAfter(node.expressions[0], astUtils.isCommaToken);
context.report({ node, loc: firstCommaToken.loc, messageId: "unexpectedCommaExpression" });
}
};
}
};