npm - claude-flow - Versions diffs - 2.0.0-alpha.7 → 2.0.0-alpha.71 - Mend

claude-flow 2.0.0-alpha.7 → 2.0.0-alpha.71

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3291) hide show

package/src/ui/extension/node_modules/eslint/lib/rules/no-unused-vars.js CHANGED Viewed

@@ -2,19 +2,14 @@
  * @fileoverview Rule to flag declared but unused variables
  * @author Ilya Volodin
  */
 "use strict";
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
 const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 /**
  * Bag of data used for formatting the `unusedVar` lint message.
  * @typedef {Object} UnusedVarMessageData
@@ -22,22 +17,18 @@ const astUtils = require("./utils/ast-utils");
  * @property {'defined'|'assigned a value'} action Description of the vars state.
  * @property {string} additional Any additional info to be appended at the end.
  */
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "problem",
         docs: {
             description: "Disallow unused variables",
             recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-unused-vars"
         },
         schema: [
             {
                 oneOf: [
@@ -77,26 +68,20 @@ module.exports = {
                 ]
             }
         ],
         messages: {
             unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}."
         }
     },
-    create(context) {
+    create(_context) {
         const sourceCode = context.sourceCode;
         const REST_PROPERTY_TYPE = /^(?:RestElement|(?:Experimental)?RestProperty)$/u;
         const config = {
             vars: "all",
             args: "after-used",
             ignoreRestSiblings: false,
             caughtErrors: "none"
         };
         const firstOption = context.options[0];
         if (firstOption) {
             if (typeof firstOption === "string") {
                 config.vars = firstOption;
@@ -105,25 +90,20 @@ module.exports = {
                 config.args = firstOption.args || config.args;
                 config.ignoreRestSiblings = firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
                 config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;
                 if (firstOption.varsIgnorePattern) {
                     config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern, "u");
                 }
                 if (firstOption.argsIgnorePattern) {
                     config.argsIgnorePattern = new RegExp(firstOption.argsIgnorePattern, "u");
                 }
                 if (firstOption.caughtErrorsIgnorePattern) {
                     config.caughtErrorsIgnorePattern = new RegExp(firstOption.caughtErrorsIgnorePattern, "u");
                 }
                 if (firstOption.destructuredArrayIgnorePattern) {
                     config.destructuredArrayIgnorePattern = new RegExp(firstOption.destructuredArrayIgnorePattern, "u");
                 }
             }
         }
         /**
          * Generates the message data about the variable being defined and unused,
          * including the ignore pattern if configured.
@@ -132,9 +112,8 @@ module.exports = {
          */
         function getDefinedMessageData(unusedVar) {
             const defType = unusedVar.defs && unusedVar.defs[0] && unusedVar.defs[0].type;
-            let type;
-            let pattern;
+            let type; // TODO: Remove if unused
+            let pattern; // TODO: Remove if unused
             if (defType === "CatchClause" && config.caughtErrorsIgnorePattern) {
                 type = "args";
                 pattern = config.caughtErrorsIgnorePattern.toString();
@@ -145,16 +124,13 @@ module.exports = {
                 type = "vars";
                 pattern = config.varsIgnorePattern.toString();
             }
             const additional = type ? `. Allowed unused ${type} must match ${pattern}` : "";
             return {
                 varName: unusedVar.name,
                 action: "defined",
                 additional
             };
         }
         /**
          * Generate the warning message about the variable being
          * assigned and unused, including the ignore pattern if configured.
@@ -164,26 +140,21 @@ module.exports = {
         function getAssignedMessageData(unusedVar) {
             const def = unusedVar.defs[0];
             let additional = "";
             if (config.destructuredArrayIgnorePattern && def && def.name.parent.type === "ArrayPattern") {
                 additional = `. Allowed unused elements of array destructuring patterns must match ${config.destructuredArrayIgnorePattern.toString()}`;
             } else if (config.varsIgnorePattern) {
                 additional = `. Allowed unused vars must match ${config.varsIgnorePattern.toString()}`;
             }
             return {
                 varName: unusedVar.name,
                 action: "assigned a value",
                 additional
             };
         }
         //--------------------------------------------------------------------------
         // Helpers
         //--------------------------------------------------------------------------
         const STATEMENT_TYPE = /(?:Statement|Declaration)$/u;
         /**
          * Determines if a given variable is being exported from a module.
          * @param {Variable} variable eslint-scope variable object.
@@ -191,25 +162,18 @@ module.exports = {
          * @private
          */
         function isExported(variable) {
             const definition = variable.defs[0];
             if (definition) {
                 let node = definition.node;
                 if (node.type === "VariableDeclarator") {
                     node = node.parent;
                 } else if (definition.type === "Parameter") {
                     return false;
                 }
                 return node.parent.type.indexOf("Export") === 0;
             }
             return false;
         }
         /**
          * Checks whether a node is a sibling of the rest property or not.
          * @param {ASTNode} node a node to check
@@ -220,7 +184,6 @@ module.exports = {
                 node.parent.type === "ObjectPattern" &&
                 REST_PROPERTY_TYPE.test(node.parent.properties[node.parent.properties.length - 1].type);
         }
         /**
          * Determines if a variable has a sibling rest property
          * @param {Variable} variable eslint-scope variable object.
@@ -231,13 +194,10 @@ module.exports = {
             if (config.ignoreRestSiblings) {
                 const hasRestSiblingDefinition = variable.defs.some(def => hasRestSibling(def.name.parent));
                 const hasRestSiblingReference = variable.references.some(ref => hasRestSibling(ref.identifier.parent));
                 return hasRestSiblingDefinition || hasRestSiblingReference;
             }
             return false;
         }
         /**
          * Determines if a reference is a read operation.
          * @param {Reference} ref An eslint-scope Reference
@@ -247,7 +207,6 @@ module.exports = {
         function isReadRef(ref) {
             return ref.isRead();
         }
         /**
          * Determine if an identifier is referencing an enclosing function name.
          * @param {Reference} ref The reference to check.
@@ -257,18 +216,14 @@ module.exports = {
          */
         function isSelfReference(ref, nodes) {
             let scope = ref.from;
             while (scope) {
                 if (nodes.includes(scope.block)) {
                     return true;
                 }
                 scope = scope.upper;
             }
             return false;
         }
         /**
          * Gets a list of function definitions for a specified variable.
          * @param {Variable} variable eslint-scope variable object.
@@ -277,15 +232,12 @@ module.exports = {
          */
         function getFunctionDefinitions(variable) {
             const functionDefinitions = [];
             variable.defs.forEach(def => {
                 const { type, node } = def;
                 // FunctionDeclarations
                 if (type === "FunctionName") {
                     functionDefinitions.push(node);
                 }
                 // FunctionExpressions
                 if (type === "Variable" && node.init &&
                     (node.init.type === "FunctionExpression" || node.init.type === "ArrowFunctionExpression")) {
@@ -294,7 +246,6 @@ module.exports = {
             });
             return functionDefinitions;
         }
         /**
          * Checks the position of given nodes.
          * @param {ASTNode} inner A node which is expected as inside.
@@ -308,7 +259,6 @@ module.exports = {
                 inner.range[1] <= outer.range[1]
             );
         }
         /**
          * Checks whether a given node is unused expression or not.
          * @param {ASTNode} node The node itself
@@ -317,23 +267,18 @@ module.exports = {
          */
         function isUnusedExpression(node) {
             const parent = node.parent;
             if (parent.type === "ExpressionStatement") {
                 return true;
             }
             if (parent.type === "SequenceExpression") {
                 const isLastExpression = parent.expressions[parent.expressions.length - 1] === node;
                 if (!isLastExpression) {
                     return true;
                 }
                 return isUnusedExpression(parent);
             }
             return false;
         }
         /**
          * If a given reference is left-hand side of an assignment, this gets
          * the right-hand side node of the assignment.
@@ -355,7 +300,6 @@ module.exports = {
             const refScope = ref.from.variableScope;
             const varScope = ref.resolved.scope.variableScope;
             const canBeUsedLater = refScope !== varScope || astUtils.isInLoop(id);
             /*
              * Inherits the previous node if this reference is in the node.
              * This is for `a = a + a`-like code.
@@ -363,7 +307,6 @@ module.exports = {
             if (prevRhsNode && isInside(id, prevRhsNode)) {
                 return prevRhsNode;
             }
             if (parent.type === "AssignmentExpression" &&
                 isUnusedExpression(parent) &&
                 id === parent.left &&
@@ -373,7 +316,6 @@ module.exports = {
             }
             return null;
         }
         /**
          * Checks whether a given function node is stored to somewhere or not.
          * If the function node is stored, the function can be used later.
@@ -388,7 +330,6 @@ module.exports = {
         function isStorableFunction(funcNode, rhsNode) {
             let node = funcNode;
             let parent = funcNode.parent;
             while (parent && isInside(parent, rhsNode)) {
                 switch (parent.type) {
                     case "SequenceExpression":
@@ -396,19 +337,15 @@ module.exports = {
                             return false;
                         }
                         break;
                     case "CallExpression":
                     case "NewExpression":
                         return parent.callee !== node;
                     case "AssignmentExpression":
                     case "TaggedTemplateExpression":
                     case "YieldExpression":
                         return true;
                     default:
                         if (STATEMENT_TYPE.test(parent.type)) {
                             /*
                              * If it encountered statements, this is a complex pattern.
                              * Since analyzing complex patterns is hard, this returns `true` to avoid false positive.
@@ -416,14 +353,11 @@ module.exports = {
                             return true;
                         }
                 }
                 node = parent;
                 parent = parent.parent;
             }
             return false;
         }
         /**
          * Checks whether a given Identifier node exists inside of a function node which can be used later.
          *
@@ -440,14 +374,12 @@ module.exports = {
          */
         function isInsideOfStorableFunction(id, rhsNode) {
             const funcNode = astUtils.getUpperFunction(id);
             return (
                 funcNode &&
                 isInside(funcNode, rhsNode) &&
                 isStorableFunction(funcNode, rhsNode)
             );
         }
         /**
          * Checks whether a given reference is a read to update itself or not.
          * @param {eslint-scope.Reference} ref A reference to check.
@@ -458,9 +390,7 @@ module.exports = {
         function isReadForItself(ref, rhsNode) {
             const id = ref.identifier;
             const parent = id.parent;
             return ref.isRead() && (
                 // self update. e.g. `a += 1`, `a++`
                 (
                     (
@@ -474,7 +404,6 @@ module.exports = {
                         isUnusedExpression(parent)
                     )
                 ) ||
                 // in RHS of an assignment for itself. e.g. `a = a + 1`
                 (
                     rhsNode &&
@@ -483,7 +412,6 @@ module.exports = {
                 )
             );
         }
         /**
          * Determine if an identifier is used either in for-in or for-of loops.
          * @param {Reference} ref The reference to check.
@@ -492,34 +420,26 @@ module.exports = {
          */
         function isForInOfRef(ref) {
             let target = ref.identifier.parent;
             // "for (var ...) { return; }"
             if (target.type === "VariableDeclarator") {
                 target = target.parent.parent;
             }
             if (target.type !== "ForInStatement" && target.type !== "ForOfStatement") {
                 return false;
             }
             // "for (...) { return; }"
             if (target.body.type === "BlockStatement") {
                 target = target.body.body[0];
             // "for (...) return;"
             } else {
                 target = target.body;
             }
             // For empty loop body
             if (!target) {
                 return false;
             }
             return target.type === "ReturnStatement";
         }
         /**
          * Determines if the variable is used.
          * @param {Variable} variable The variable to check.
@@ -530,16 +450,12 @@ module.exports = {
             const functionNodes = getFunctionDefinitions(variable),
                 isFunctionDefinition = functionNodes.length > 0;
             let rhsNode = null;
             return variable.references.some(ref => {
                 if (isForInOfRef(ref)) {
                     return true;
                 }
                 const forItself = isReadForItself(ref, rhsNode);
                 rhsNode = getRhsNode(ref, rhsNode);
                 return (
                     isReadRef(ref) &&
                     !forItself &&
@@ -547,7 +463,6 @@ module.exports = {
                 );
             });
         }
         /**
          * Checks whether the given variable is after the last used parameter.
          * @param {eslint-scope.Variable} variable The variable to check.
@@ -558,11 +473,9 @@ module.exports = {
             const def = variable.defs[0];
             const params = sourceCode.getDeclaredVariables(def.node);
             const posteriorParams = params.slice(params.indexOf(variable) + 1);
             // If any used parameters occur after this parameter, do not report.
             return !posteriorParams.some(v => v.references.length > 0 || v.eslintUsed);
         }
         /**
          * Gets an array of variables without read references.
          * @param {Scope} scope an eslint-scope Scope object.
@@ -573,34 +486,27 @@ module.exports = {
         function collectUnusedVariables(scope, unusedVars) {
             const variables = scope.variables;
             const childScopes = scope.childScopes;
-            let i, l;
+            let i, l; // TODO: Remove if unused
             if (scope.type !== "global" || config.vars === "all") {
                 for (i = 0, l = variables.length; i < l; ++i) {
                     const variable = variables[i];
                     // skip a variable of class itself name in the class scope
                     if (scope.type === "class" && scope.block.id === variable.identifiers[0]) {
                         continue;
                     }
                     // skip function expression names and variables marked with markVariableAsUsed()
                     if (scope.functionExpressionScope || variable.eslintUsed) {
                         continue;
                     }
                     // skip implicit "arguments" variable
                     if (scope.type === "function" && variable.name === "arguments" && variable.identifiers.length === 0) {
                         continue;
                     }
                     // explicit global variables don't have definitions.
                     const def = variable.defs[0];
                     if (def) {
                         const type = def.type;
                         const refUsedInArrayPatterns = variable.references.some(ref => ref.identifier.parent.type === "ArrayPattern");
                         // skip elements of array destructuring patterns
                         if (
                             (
@@ -612,85 +518,66 @@ module.exports = {
                         ) {
                             continue;
                         }
                         // skip catch variables
                         if (type === "CatchClause") {
                             if (config.caughtErrors === "none") {
                                 continue;
                             }
                             // skip ignored parameters
                             if (config.caughtErrorsIgnorePattern && config.caughtErrorsIgnorePattern.test(def.name.name)) {
                                 continue;
                             }
                         }
                         if (type === "Parameter") {
                             // skip any setter argument
                             if ((def.node.parent.type === "Property" || def.node.parent.type === "MethodDefinition") && def.node.parent.kind === "set") {
                                 continue;
                             }
                             // if "args" option is "none", skip any parameter
                             if (config.args === "none") {
                                 continue;
                             }
                             // skip ignored parameters
                             if (config.argsIgnorePattern && config.argsIgnorePattern.test(def.name.name)) {
                                 continue;
                             }
                             // if "args" option is "after-used", skip used variables
                             if (config.args === "after-used" && astUtils.isFunction(def.name.parent) && !isAfterLastUsedArg(variable)) {
                                 continue;
                             }
                         } else {
                             // skip ignored variables
                             if (config.varsIgnorePattern && config.varsIgnorePattern.test(def.name.name)) {
                                 continue;
                             }
                         }
                     }
                     if (!isUsedVariable(variable) && !isExported(variable) && !hasRestSpreadSibling(variable)) {
                         unusedVars.push(variable);
                     }
                 }
             }
             for (i = 0, l = childScopes.length; i < l; ++i) {
                 collectUnusedVariables(childScopes[i], unusedVars);
             }
             return unusedVars;
         }
         //--------------------------------------------------------------------------
         // Public
         //--------------------------------------------------------------------------
         return {
             "Program:exit"(programNode) {
                 const unusedVars = collectUnusedVariables(sourceCode.getScope(programNode), []);
                 for (let i = 0, l = unusedVars.length; i < l; ++i) {
                     const unusedVar = unusedVars[i];
                     // Report the first declaration.
                     if (unusedVar.defs.length > 0) {
                         // report last write reference, https://github.com/eslint/eslint/issues/14324
                         const writeReferences = unusedVar.references.filter(ref => ref.isWrite() && ref.from.variableScope === unusedVar.scope.variableScope);
-                        let referenceToReport;
+                        let referenceToReport; // TODO: Remove if unused
                         if (writeReferences.length > 0) {
                             referenceToReport = writeReferences[writeReferences.length - 1];
                         }
                         context.report({
                             node: referenceToReport ? referenceToReport.identifier : unusedVar.identifiers[0],
                             messageId: "unusedVar",
@@ -698,11 +585,9 @@ module.exports = {
                                 ? getAssignedMessageData(unusedVar)
                                 : getDefinedMessageData(unusedVar)
                         });
                     // If there are no regular declaration, report the first `/*globals*/` comment directive.
                     } else if (unusedVar.eslintExplicitGlobalComments) {
                         const directiveComment = unusedVar.eslintExplicitGlobalComments[0];
                         context.report({
                             node: programNode,
                             loc: astUtils.getNameLocationInGlobalDirectiveComment(sourceCode, directiveComment, unusedVar.name),
@@ -713,6 +598,5 @@ module.exports = {
                 }
             }
         };
     }
-};
+};