source: imaps-frontend/node_modules/eslint/lib/rules/id-denylist.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: 7.0 KB
Line 
1/**
2 * @fileoverview Rule that warns when identifier names that are
3 * specified in the configuration are used.
4 * @author Keith Cirkel (http://keithcirkel.co.uk)
5 */
6
7"use strict";
8
9//------------------------------------------------------------------------------
10// Helpers
11//------------------------------------------------------------------------------
12
13/**
14 * Checks whether the given node represents assignment target in a normal assignment or destructuring.
15 * @param {ASTNode} node The node to check.
16 * @returns {boolean} `true` if the node is assignment target.
17 */
18function isAssignmentTarget(node) {
19 const parent = node.parent;
20
21 return (
22
23 // normal assignment
24 (
25 parent.type === "AssignmentExpression" &&
26 parent.left === node
27 ) ||
28
29 // destructuring
30 parent.type === "ArrayPattern" ||
31 parent.type === "RestElement" ||
32 (
33 parent.type === "Property" &&
34 parent.value === node &&
35 parent.parent.type === "ObjectPattern"
36 ) ||
37 (
38 parent.type === "AssignmentPattern" &&
39 parent.left === node
40 )
41 );
42}
43
44/**
45 * Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
46 *
47 * Examples:
48 * import { a as b } from 'mod'; // node `a` is renamed import
49 * export { a as b } from 'mod'; // node `a` is renamed import
50 * @param {ASTNode} node `Identifier` node to check.
51 * @returns {boolean} `true` if the node is a renamed import.
52 */
53function isRenamedImport(node) {
54 const parent = node.parent;
55
56 return (
57 (
58 parent.type === "ImportSpecifier" &&
59 parent.imported !== parent.local &&
60 parent.imported === node
61 ) ||
62 (
63 parent.type === "ExportSpecifier" &&
64 parent.parent.source && // re-export
65 parent.local !== parent.exported &&
66 parent.local === node
67 )
68 );
69}
70
71/**
72 * Checks whether the given node is an ObjectPattern destructuring.
73 *
74 * Examples:
75 * const { a : b } = foo;
76 * @param {ASTNode} node `Identifier` node to check.
77 * @returns {boolean} `true` if the node is in an ObjectPattern destructuring.
78 */
79function isPropertyNameInDestructuring(node) {
80 const parent = node.parent;
81
82 return (
83 (
84 !parent.computed &&
85 parent.type === "Property" &&
86 parent.parent.type === "ObjectPattern" &&
87 parent.key === node
88 )
89 );
90}
91
92//------------------------------------------------------------------------------
93// Rule Definition
94//------------------------------------------------------------------------------
95
96/** @type {import('../shared/types').Rule} */
97module.exports = {
98 meta: {
99 type: "suggestion",
100
101 docs: {
102 description: "Disallow specified identifiers",
103 recommended: false,
104 url: "https://eslint.org/docs/latest/rules/id-denylist"
105 },
106
107 schema: {
108 type: "array",
109 items: {
110 type: "string"
111 },
112 uniqueItems: true
113 },
114 messages: {
115 restricted: "Identifier '{{name}}' is restricted.",
116 restrictedPrivate: "Identifier '#{{name}}' is restricted."
117 }
118 },
119
120 create(context) {
121
122 const denyList = new Set(context.options);
123 const reportedNodes = new Set();
124 const sourceCode = context.sourceCode;
125
126 let globalScope;
127
128 /**
129 * Checks whether the given name is restricted.
130 * @param {string} name The name to check.
131 * @returns {boolean} `true` if the name is restricted.
132 * @private
133 */
134 function isRestricted(name) {
135 return denyList.has(name);
136 }
137
138 /**
139 * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
140 * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
141 * @param {ASTNode} node `Identifier` node to check.
142 * @returns {boolean} `true` if the node is a reference to a global variable.
143 */
144 function isReferenceToGlobalVariable(node) {
145 const variable = globalScope.set.get(node.name);
146
147 return variable && variable.defs.length === 0 &&
148 variable.references.some(ref => ref.identifier === node);
149 }
150
151 /**
152 * Determines whether the given node should be checked.
153 * @param {ASTNode} node `Identifier` node.
154 * @returns {boolean} `true` if the node should be checked.
155 */
156 function shouldCheck(node) {
157 const parent = node.parent;
158
159 /*
160 * Member access has special rules for checking property names.
161 * Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over.
162 * Write access isn't allowed, because it potentially creates a new property with a restricted name.
163 */
164 if (
165 parent.type === "MemberExpression" &&
166 parent.property === node &&
167 !parent.computed
168 ) {
169 return isAssignmentTarget(parent);
170 }
171
172 return (
173 parent.type !== "CallExpression" &&
174 parent.type !== "NewExpression" &&
175 !isRenamedImport(node) &&
176 !isPropertyNameInDestructuring(node) &&
177 !isReferenceToGlobalVariable(node)
178 );
179 }
180
181 /**
182 * Reports an AST node as a rule violation.
183 * @param {ASTNode} node The node to report.
184 * @returns {void}
185 * @private
186 */
187 function report(node) {
188
189 /*
190 * We used the range instead of the node because it's possible
191 * for the same identifier to be represented by two different
192 * nodes, with the most clear example being shorthand properties:
193 * { foo }
194 * In this case, "foo" is represented by one node for the name
195 * and one for the value. The only way to know they are the same
196 * is to look at the range.
197 */
198 if (!reportedNodes.has(node.range.toString())) {
199 const isPrivate = node.type === "PrivateIdentifier";
200
201 context.report({
202 node,
203 messageId: isPrivate ? "restrictedPrivate" : "restricted",
204 data: {
205 name: node.name
206 }
207 });
208 reportedNodes.add(node.range.toString());
209 }
210 }
211
212 return {
213
214 Program(node) {
215 globalScope = sourceCode.getScope(node);
216 },
217
218 [[
219 "Identifier",
220 "PrivateIdentifier"
221 ]](node) {
222 if (isRestricted(node.name) && shouldCheck(node)) {
223 report(node);
224 }
225 }
226 };
227 }
228};
Note: See TracBrowser for help on using the repository browser.