source: imaps-frontend/node_modules/eslint/lib/rules/prefer-destructuring.js

main
Last change on this file was d565449, checked in by stefan toskovski <stefantoska84@…>, 4 weeks ago

Update repo after prototype presentation
  • Property mode set to 100644
File size: 10.9 KB
Line 
1/**
2 * @fileoverview Prefer destructuring from arrays and objects
3 * @author Alex LaFroscia
4 */
5"use strict";
6
7//------------------------------------------------------------------------------
8// Requirements
9//------------------------------------------------------------------------------
10
11const astUtils = require("./utils/ast-utils");
12
13//------------------------------------------------------------------------------
14// Helpers
15//------------------------------------------------------------------------------
16
17const PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({ type: "AssignmentExpression" });
18
19//------------------------------------------------------------------------------
20// Rule Definition
21//------------------------------------------------------------------------------
22
23/** @type {import('../shared/types').Rule} */
24module.exports = {
25 meta: {
26 type: "suggestion",
27
28 docs: {
29 description: "Require destructuring from arrays and/or objects",
30 recommended: false,
31 url: "https://eslint.org/docs/latest/rules/prefer-destructuring"
32 },
33
34 fixable: "code",
35
36 schema: [
37 {
38
39 /*
40 * old support {array: Boolean, object: Boolean}
41 * new support {VariableDeclarator: {}, AssignmentExpression: {}}
42 */
43 oneOf: [
44 {
45 type: "object",
46 properties: {
47 VariableDeclarator: {
48 type: "object",
49 properties: {
50 array: {
51 type: "boolean"
52 },
53 object: {
54 type: "boolean"
55 }
56 },
57 additionalProperties: false
58 },
59 AssignmentExpression: {
60 type: "object",
61 properties: {
62 array: {
63 type: "boolean"
64 },
65 object: {
66 type: "boolean"
67 }
68 },
69 additionalProperties: false
70 }
71 },
72 additionalProperties: false
73 },
74 {
75 type: "object",
76 properties: {
77 array: {
78 type: "boolean"
79 },
80 object: {
81 type: "boolean"
82 }
83 },
84 additionalProperties: false
85 }
86 ]
87 },
88 {
89 type: "object",
90 properties: {
91 enforceForRenamedProperties: {
92 type: "boolean"
93 }
94 },
95 additionalProperties: false
96 }
97 ],
98
99 messages: {
100 preferDestructuring: "Use {{type}} destructuring."
101 }
102 },
103 create(context) {
104
105 const enabledTypes = context.options[0];
106 const enforceForRenamedProperties = context.options[1] && context.options[1].enforceForRenamedProperties;
107 let normalizedOptions = {
108 VariableDeclarator: { array: true, object: true },
109 AssignmentExpression: { array: true, object: true }
110 };
111
112 if (enabledTypes) {
113 normalizedOptions = typeof enabledTypes.array !== "undefined" || typeof enabledTypes.object !== "undefined"
114 ? { VariableDeclarator: enabledTypes, AssignmentExpression: enabledTypes }
115 : enabledTypes;
116 }
117
118 //--------------------------------------------------------------------------
119 // Helpers
120 //--------------------------------------------------------------------------
121
122 /**
123 * Checks if destructuring type should be checked.
124 * @param {string} nodeType "AssignmentExpression" or "VariableDeclarator"
125 * @param {string} destructuringType "array" or "object"
126 * @returns {boolean} `true` if the destructuring type should be checked for the given node
127 */
128 function shouldCheck(nodeType, destructuringType) {
129 return normalizedOptions &&
130 normalizedOptions[nodeType] &&
131 normalizedOptions[nodeType][destructuringType];
132 }
133
134 /**
135 * Determines if the given node is accessing an array index
136 *
137 * This is used to differentiate array index access from object property
138 * access.
139 * @param {ASTNode} node the node to evaluate
140 * @returns {boolean} whether or not the node is an integer
141 */
142 function isArrayIndexAccess(node) {
143 return Number.isInteger(node.property.value);
144 }
145
146 /**
147 * Report that the given node should use destructuring
148 * @param {ASTNode} reportNode the node to report
149 * @param {string} type the type of destructuring that should have been done
150 * @param {Function|null} fix the fix function or null to pass to context.report
151 * @returns {void}
152 */
153 function report(reportNode, type, fix) {
154 context.report({
155 node: reportNode,
156 messageId: "preferDestructuring",
157 data: { type },
158 fix
159 });
160 }
161
162 /**
163 * Determines if a node should be fixed into object destructuring
164 *
165 * The fixer only fixes the simplest case of object destructuring,
166 * like: `let x = a.x`;
167 *
168 * Assignment expression is not fixed.
169 * Array destructuring is not fixed.
170 * Renamed property is not fixed.
171 * @param {ASTNode} node the node to evaluate
172 * @returns {boolean} whether or not the node should be fixed
173 */
174 function shouldFix(node) {
175 return node.type === "VariableDeclarator" &&
176 node.id.type === "Identifier" &&
177 node.init.type === "MemberExpression" &&
178 !node.init.computed &&
179 node.init.property.type === "Identifier" &&
180 node.id.name === node.init.property.name;
181 }
182
183 /**
184 * Fix a node into object destructuring.
185 * This function only handles the simplest case of object destructuring,
186 * see {@link shouldFix}.
187 * @param {SourceCodeFixer} fixer the fixer object
188 * @param {ASTNode} node the node to be fixed.
189 * @returns {Object} a fix for the node
190 */
191 function fixIntoObjectDestructuring(fixer, node) {
192 const rightNode = node.init;
193 const sourceCode = context.sourceCode;
194
195 // Don't fix if that would remove any comments. Only comments inside `rightNode.object` can be preserved.
196 if (sourceCode.getCommentsInside(node).length > sourceCode.getCommentsInside(rightNode.object).length) {
197 return null;
198 }
199
200 let objectText = sourceCode.getText(rightNode.object);
201
202 if (astUtils.getPrecedence(rightNode.object) < PRECEDENCE_OF_ASSIGNMENT_EXPR) {
203 objectText = `(${objectText})`;
204 }
205
206 return fixer.replaceText(
207 node,
208 `{${rightNode.property.name}} = ${objectText}`
209 );
210 }
211
212 /**
213 * Check that the `prefer-destructuring` rules are followed based on the
214 * given left- and right-hand side of the assignment.
215 *
216 * Pulled out into a separate method so that VariableDeclarators and
217 * AssignmentExpressions can share the same verification logic.
218 * @param {ASTNode} leftNode the left-hand side of the assignment
219 * @param {ASTNode} rightNode the right-hand side of the assignment
220 * @param {ASTNode} reportNode the node to report the error on
221 * @returns {void}
222 */
223 function performCheck(leftNode, rightNode, reportNode) {
224 if (
225 rightNode.type !== "MemberExpression" ||
226 rightNode.object.type === "Super" ||
227 rightNode.property.type === "PrivateIdentifier"
228 ) {
229 return;
230 }
231
232 if (isArrayIndexAccess(rightNode)) {
233 if (shouldCheck(reportNode.type, "array")) {
234 report(reportNode, "array", null);
235 }
236 return;
237 }
238
239 const fix = shouldFix(reportNode)
240 ? fixer => fixIntoObjectDestructuring(fixer, reportNode)
241 : null;
242
243 if (shouldCheck(reportNode.type, "object") && enforceForRenamedProperties) {
244 report(reportNode, "object", fix);
245 return;
246 }
247
248 if (shouldCheck(reportNode.type, "object")) {
249 const property = rightNode.property;
250
251 if (
252 (property.type === "Literal" && leftNode.name === property.value) ||
253 (property.type === "Identifier" && leftNode.name === property.name && !rightNode.computed)
254 ) {
255 report(reportNode, "object", fix);
256 }
257 }
258 }
259
260 /**
261 * Check if a given variable declarator is coming from an property access
262 * that should be using destructuring instead
263 * @param {ASTNode} node the variable declarator to check
264 * @returns {void}
265 */
266 function checkVariableDeclarator(node) {
267
268 // Skip if variable is declared without assignment
269 if (!node.init) {
270 return;
271 }
272
273 // We only care about member expressions past this point
274 if (node.init.type !== "MemberExpression") {
275 return;
276 }
277
278 performCheck(node.id, node.init, node);
279 }
280
281 /**
282 * Run the `prefer-destructuring` check on an AssignmentExpression
283 * @param {ASTNode} node the AssignmentExpression node
284 * @returns {void}
285 */
286 function checkAssignmentExpression(node) {
287 if (node.operator === "=") {
288 performCheck(node.left, node.right, node);
289 }
290 }
291
292 //--------------------------------------------------------------------------
293 // Public
294 //--------------------------------------------------------------------------
295
296 return {
297 VariableDeclarator: checkVariableDeclarator,
298 AssignmentExpression: checkAssignmentExpression
299 };
300 }
301};
Note: See TracBrowser for help on using the repository browser.