.config/coc/extensions/node_modules/coc-prettier/node_modules/eslint/lib/rules/func-name-matching.js

   1 /**
   2  * @fileoverview Rule to require function names to match the name of the variable or property to which they are assigned.
   3  * @author Annie Zhang, Pavel Strashkin
   4  */
   5
   6 "use strict";
   7
   8 //--------------------------------------------------------------------------
   9 // Requirements
  10 //--------------------------------------------------------------------------
  11
  12 const astUtils = require("./utils/ast-utils");
  13 const esutils = require("esutils");
  14
  15 //--------------------------------------------------------------------------
  16 // Helpers
  17 //--------------------------------------------------------------------------
  18
  19 /**
  20  * Determines if a pattern is `module.exports` or `module["exports"]`
  21  * @param {ASTNode} pattern The left side of the AssignmentExpression
  22  * @returns {boolean} True if the pattern is `module.exports` or `module["exports"]`
  23  */
  24 function isModuleExports(pattern) {
  25     if (pattern.type === "MemberExpression" && pattern.object.type === "Identifier" && pattern.object.name === "module") {
  26
  27         // module.exports
  28         if (pattern.property.type === "Identifier" && pattern.property.name === "exports") {
  29             return true;
  30         }
  31
  32         // module["exports"]
  33         if (pattern.property.type === "Literal" && pattern.property.value === "exports") {
  34             return true;
  35         }
  36     }
  37     return false;
  38 }
  39
  40 /**
  41  * Determines if a string name is a valid identifier
  42  * @param {string} name The string to be checked
  43  * @param {int} ecmaVersion The ECMAScript version if specified in the parserOptions config
  44  * @returns {boolean} True if the string is a valid identifier
  45  */
  46 function isIdentifier(name, ecmaVersion) {
  47     if (ecmaVersion >= 6) {
  48         return esutils.keyword.isIdentifierES6(name);
  49     }
  50     return esutils.keyword.isIdentifierES5(name);
  51 }
  52
  53 //------------------------------------------------------------------------------
  54 // Rule Definition
  55 //------------------------------------------------------------------------------
  56
  57 const alwaysOrNever = { enum: ["always", "never"] };
  58 const optionsObject = {
  59     type: "object",
  60     properties: {
  61         considerPropertyDescriptor: {
  62             type: "boolean"
  63         },
  64         includeCommonJSModuleExports: {
  65             type: "boolean"
  66         }
  67     },
  68     additionalProperties: false
  69 };
  70
  71 module.exports = {
  72     meta: {
  73         type: "suggestion",
  74
  75         docs: {
  76             description: "require function names to match the name of the variable or property to which they are assigned",
  77             category: "Stylistic Issues",
  78             recommended: false,
  79             url: "https://eslint.org/docs/rules/func-name-matching"
  80         },
  81
  82         schema: {
  83             anyOf: [{
  84                 type: "array",
  85                 additionalItems: false,
  86                 items: [alwaysOrNever, optionsObject]
  87             }, {
  88                 type: "array",
  89                 additionalItems: false,
  90                 items: [optionsObject]
  91             }]
  92         },
  93
  94         messages: {
  95             matchProperty: "Function name `{{funcName}}` should match property name `{{name}}`.",
  96             matchVariable: "Function name `{{funcName}}` should match variable name `{{name}}`.",
  97             notMatchProperty: "Function name `{{funcName}}` should not match property name `{{name}}`.",
  98             notMatchVariable: "Function name `{{funcName}}` should not match variable name `{{name}}`."
  99         }
 100     },
 101
 102     create(context) {
 103         const options = (typeof context.options[0] === "object" ? context.options[0] : context.options[1]) || {};
 104         const nameMatches = typeof context.options[0] === "string" ? context.options[0] : "always";
 105         const considerPropertyDescriptor = options.considerPropertyDescriptor;
 106         const includeModuleExports = options.includeCommonJSModuleExports;
 107         const ecmaVersion = context.parserOptions && context.parserOptions.ecmaVersion ? context.parserOptions.ecmaVersion : 5;
 108
 109         /**
 110          * Check whether node is a certain CallExpression.
 111          * @param {string} objName object name
 112          * @param {string} funcName function name
 113          * @param {ASTNode} node The node to check
 114          * @returns {boolean} `true` if node matches CallExpression
 115          */
 116         function isPropertyCall(objName, funcName, node) {
 117             if (!node) {
 118                 return false;
 119             }
 120             return node.type === "CallExpression" &&
 121                 node.callee.type === "MemberExpression" &&
 122                 node.callee.object.name === objName &&
 123                 node.callee.property.name === funcName;
 124         }
 125
 126         /**
 127          * Compares identifiers based on the nameMatches option
 128          * @param {string} x the first identifier
 129          * @param {string} y the second identifier
 130          * @returns {boolean} whether the two identifiers should warn.
 131          */
 132         function shouldWarn(x, y) {
 133             return (nameMatches === "always" && x !== y) || (nameMatches === "never" && x === y);
 134         }
 135
 136         /**
 137          * Reports
 138          * @param {ASTNode} node The node to report
 139          * @param {string} name The variable or property name
 140          * @param {string} funcName The function name
 141          * @param {boolean} isProp True if the reported node is a property assignment
 142          * @returns {void}
 143          */
 144         function report(node, name, funcName, isProp) {
 145             let messageId;
 146
 147             if (nameMatches === "always" && isProp) {
 148                 messageId = "matchProperty";
 149             } else if (nameMatches === "always") {
 150                 messageId = "matchVariable";
 151             } else if (isProp) {
 152                 messageId = "notMatchProperty";
 153             } else {
 154                 messageId = "notMatchVariable";
 155             }
 156             context.report({
 157                 node,
 158                 messageId,
 159                 data: {
 160                     name,
 161                     funcName
 162                 }
 163             });
 164         }
 165
 166         /**
 167          * Determines whether a given node is a string literal
 168          * @param {ASTNode} node The node to check
 169          * @returns {boolean} `true` if the node is a string literal
 170          */
 171         function isStringLiteral(node) {
 172             return node.type === "Literal" && typeof node.value === "string";
 173         }
 174
 175         //--------------------------------------------------------------------------
 176         // Public
 177         //--------------------------------------------------------------------------
 178
 179         return {
 180             VariableDeclarator(node) {
 181                 if (!node.init || node.init.type !== "FunctionExpression" || node.id.type !== "Identifier") {
 182                     return;
 183                 }
 184                 if (node.init.id && shouldWarn(node.id.name, node.init.id.name)) {
 185                     report(node, node.id.name, node.init.id.name, false);
 186                 }
 187             },
 188
 189             AssignmentExpression(node) {
 190                 if (
 191                     node.right.type !== "FunctionExpression" ||
 192                     (node.left.computed && node.left.property.type !== "Literal") ||
 193                     (!includeModuleExports && isModuleExports(node.left)) ||
 194                     (node.left.type !== "Identifier" && node.left.type !== "MemberExpression")
 195                 ) {
 196                     return;
 197                 }
 198
 199                 const isProp = node.left.type === "MemberExpression";
 200                 const name = isProp ? astUtils.getStaticPropertyName(node.left) : node.left.name;
 201
 202                 if (node.right.id && isIdentifier(name) && shouldWarn(name, node.right.id.name)) {
 203                     report(node, name, node.right.id.name, isProp);
 204                 }
 205             },
 206
 207             Property(node) {
 208                 if (node.value.type !== "FunctionExpression" || !node.value.id || node.computed && !isStringLiteral(node.key)) {
 209                     return;
 210                 }
 211
 212                 if (node.key.type === "Identifier") {
 213                     const functionName = node.value.id.name;
 214                     let propertyName = node.key.name;
 215
 216                     if (considerPropertyDescriptor && propertyName === "value") {
 217                         if (isPropertyCall("Object", "defineProperty", node.parent.parent) || isPropertyCall("Reflect", "defineProperty", node.parent.parent)) {
 218                             const property = node.parent.parent.arguments[1];
 219
 220                             if (isStringLiteral(property) && shouldWarn(property.value, functionName)) {
 221                                 report(node, property.value, functionName, true);
 222                             }
 223                         } else if (isPropertyCall("Object", "defineProperties", node.parent.parent.parent.parent)) {
 224                             propertyName = node.parent.parent.key.name;
 225                             if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {
 226                                 report(node, propertyName, functionName, true);
 227                             }
 228                         } else if (isPropertyCall("Object", "create", node.parent.parent.parent.parent)) {
 229                             propertyName = node.parent.parent.key.name;
 230                             if (!node.parent.parent.computed && shouldWarn(propertyName, functionName)) {
 231                                 report(node, propertyName, functionName, true);
 232                             }
 233                         } else if (shouldWarn(propertyName, functionName)) {
 234                             report(node, propertyName, functionName, true);
 235                         }
 236                     } else if (shouldWarn(propertyName, functionName)) {
 237                         report(node, propertyName, functionName, true);
 238                     }
 239                     return;
 240                 }
 241
 242                 if (
 243                     isStringLiteral(node.key) &&
 244                     isIdentifier(node.key.value, ecmaVersion) &&
 245                     shouldWarn(node.key.value, node.value.id.name)
 246                 ) {
 247                     report(node, node.key.value, node.value.id.name, true);
 248                 }
 249             }
 250         };
 251     }
 252 };