claude-flow 2.0.0-alpha.6 → 2.0.0-alpha.61

package/src/ui/extension/node_modules/eslint/lib/rules/constructor-super.js

@@ -2,29 +2,23 @@
  * @fileoverview A rule to verify `super()` callings in constructor.
  * @author Toru Nagashima
  */
-
 "use strict";
-
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
-
 /**
  * Checks all segments in a set and returns true if any are reachable.
  * @param {Set<CodePathSegment>} segments The segments to check.
  * @returns {boolean} True if any segment is reachable; false otherwise.
  */
 function isAnySegmentReachable(segments) {
-
     for (const segment of segments) {
         if (segment.reachable) {
             return true;
         }
     }
-
     return false;
 }
-
 /**
  * Checks whether or not a given node is a constructor.
  * @param {ASTNode} node A node to check. This node type is one of
@@ -39,7 +33,6 @@ function isConstructorFunction(node) {
         node.parent.kind === "constructor"
     );
 }
-
 /**
  * Checks whether a given node can be a constructor or not.
  * @param {ASTNode} node A node to check.
@@ -49,7 +42,6 @@ function isPossibleConstructor(node) {
     if (!node) {
         return false;
     }
-
     switch (node.type) {
         case "ClassExpression":
         case "FunctionExpression":
@@ -62,31 +54,25 @@ function isPossibleConstructor(node) {
         case "TaggedTemplateExpression":
         case "MetaProperty":
             return true;
-
         case "Identifier":
             return node.name !== "undefined";
-
         case "AssignmentExpression":
             if (["=", "&&="].includes(node.operator)) {
                 return isPossibleConstructor(node.right);
             }
-
             if (["||=", "??="].includes(node.operator)) {
                 return (
                     isPossibleConstructor(node.left) ||
                     isPossibleConstructor(node.right)
                 );
             }
-
             /**
              * All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
              * An assignment expression with a mathematical operator can either evaluate to a primitive value,
              * or throw, depending on the operands. Thus, it cannot evaluate to a constructor function.
              */
             return false;
-
         case "LogicalExpression":
-
             /*
              * If the && operator short-circuits, the left side was falsy and therefore not a constructor, and if
              * it doesn't short-circuit, it takes the value from the right side, so the right side must always be a
@@ -96,58 +82,45 @@ function isPossibleConstructor(node) {
             if (node.operator === "&&") {
                 return isPossibleConstructor(node.right);
             }
-
             return (
                 isPossibleConstructor(node.left) ||
                 isPossibleConstructor(node.right)
             );
-
         case "ConditionalExpression":
             return (
                 isPossibleConstructor(node.alternate) ||
                 isPossibleConstructor(node.consequent)
             );
-
         case "SequenceExpression": {
             const lastExpression = node.expressions[node.expressions.length - 1];
-
             return isPossibleConstructor(lastExpression);
         }
-
         default:
             return false;
     }
 }
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
-
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "problem",
-
         docs: {
             description: "Require `super()` calls in constructors",
             recommended: true,
             url: "https://eslint.org/docs/latest/rules/constructor-super"
         },
-
         schema: [],
-
         messages: {
             missingSome: "Lacked a call of 'super()' in some code paths.",
             missingAll: "Expected to call 'super()'.",
-
             duplicate: "Unexpected duplicate 'super()'.",
             badSuper: "Unexpected 'super()' because 'super' is not a constructor.",
             unexpected: "Unexpected 'super()'."
         }
     },
-
-    create(context) {
-
+    create(_context) {
         /*
          * {{hasExtends: boolean, scope: Scope, codePath: CodePath}[]}
          * Information for each constructor.
@@ -158,7 +131,6 @@ module.exports = {
          * - codePath:   The code path object of the constructor.
          */
         let funcInfo = null;
-
         /*
          * {Map<string, {calledInSomePaths: boolean, calledInEveryPaths: boolean}>}
          * Information for each code path segment.
@@ -167,7 +139,6 @@ module.exports = {
          * - validNodes:
          */
         let segInfoMap = Object.create(null);
-
         /**
          * Gets the flag which shows `super()` is called in some paths.
          * @param {CodePathSegment} segment A code path segment to get.
@@ -176,14 +147,12 @@ module.exports = {
         function isCalledInSomePath(segment) {
             return segment.reachable && segInfoMap[segment.id].calledInSomePaths;
         }
-
         /**
          * Gets the flag which shows `super()` is called in all paths.
          * @param {CodePathSegment} segment A code path segment to get.
          * @returns {boolean} The flag which shows `super()` is called in all paths.
          */
         function isCalledInEveryPath(segment) {
-
             /*
              * If specific segment is the looped segment of the current segment,
              * skip the segment.
@@ -196,9 +165,7 @@ module.exports = {
             }
             return segment.reachable && segInfoMap[segment.id].calledInEveryPaths;
         }
-
         return {
-
             /**
              * Stacks a constructor information.
              * @param {CodePath} codePath A code path which was started.
@@ -207,11 +174,9 @@ module.exports = {
              */
             onCodePathStart(codePath, node) {
                 if (isConstructorFunction(node)) {
-
                     // Class > ClassBody > MethodDefinition > FunctionExpression
                     const classNode = node.parent.parent.parent;
                     const superClass = classNode.superClass;
-
                     funcInfo = {
                         upper: funcInfo,
                         isConstructor: true,
@@ -231,7 +196,6 @@ module.exports = {
                     };
                 }
             },
-
             /**
              * Pops a constructor information.
              * And reports if `super()` lacked.
@@ -241,19 +205,15 @@ module.exports = {
              */
             onCodePathEnd(codePath, node) {
                 const hasExtends = funcInfo.hasExtends;
-
                 // Pop.
                 funcInfo = funcInfo.upper;
-
                 if (!hasExtends) {
                     return;
                 }
-
                 // Reports if `super()` lacked.
                 const segments = codePath.returnedSegments;
                 const calledInEveryPaths = segments.every(isCalledInEveryPath);
                 const calledInSomePaths = segments.some(isCalledInSomePath);
-
                 if (!calledInEveryPaths) {
                     context.report({
                         messageId: calledInSomePaths
@@ -263,49 +223,38 @@ module.exports = {
                     });
                 }
             },
-
             /**
              * Initialize information of a given code path segment.
              * @param {CodePathSegment} segment A code path segment to initialize.
              * @returns {void}
              */
             onCodePathSegmentStart(segment) {
-
                 funcInfo.currentSegments.add(segment);
-
                 if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
-
                 // Initialize info.
                 const info = segInfoMap[segment.id] = {
                     calledInSomePaths: false,
                     calledInEveryPaths: false,
                     validNodes: []
                 };
-
                 // When there are previous segments, aggregates these.
                 const prevSegments = segment.prevSegments;
-
                 if (prevSegments.length > 0) {
                     info.calledInSomePaths = prevSegments.some(isCalledInSomePath);
                     info.calledInEveryPaths = prevSegments.every(isCalledInEveryPath);
                 }
             },
-
             onUnreachableCodePathSegmentStart(segment) {
                 funcInfo.currentSegments.add(segment);
             },
-
             onUnreachableCodePathSegmentEnd(segment) {
                 funcInfo.currentSegments.delete(segment);
             },
-
             onCodePathSegmentEnd(segment) {
                 funcInfo.currentSegments.delete(segment);
             },
-
-
             /**
              * Update information of the code path segment when a code path was
              * looped.
@@ -319,29 +268,22 @@ module.exports = {
                 if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
-
                 // Update information inside of the loop.
                 const isRealLoop = toSegment.prevSegments.length >= 2;
-
                 funcInfo.codePath.traverseSegments(
                     { first: toSegment, last: fromSegment },
                     segment => {
                         const info = segInfoMap[segment.id];
                         const prevSegments = segment.prevSegments;
-
                         // Updates flags.
                         info.calledInSomePaths = prevSegments.some(isCalledInSomePath);
                         info.calledInEveryPaths = prevSegments.every(isCalledInEveryPath);
-
                         // If flags become true anew, reports the valid nodes.
                         if (info.calledInSomePaths || isRealLoop) {
                             const nodes = info.validNodes;
-
                             info.validNodes = [];
-
                             for (let i = 0; i < nodes.length; ++i) {
                                 const node = nodes[i];
-
                                 context.report({
                                     messageId: "duplicate",
                                     node
@@ -351,7 +293,6 @@ module.exports = {
                     }
                 );
             },
-
             /**
              * Checks for a call of `super()`.
              * @param {ASTNode} node A CallExpression node to check.
@@ -361,28 +302,22 @@ module.exports = {
                 if (!(funcInfo && funcInfo.isConstructor)) {
                     return;
                 }
-
                 // Skips except `super()`.
                 if (node.callee.type !== "Super") {
                     return;
                 }
-
                 // Reports if needed.
                 if (funcInfo.hasExtends) {
                     const segments = funcInfo.currentSegments;
                     let duplicate = false;
                     let info = null;
-
                     for (const segment of segments) {
-
                         if (segment.reachable) {
                             info = segInfoMap[segment.id];
-
                             duplicate = duplicate || info.calledInSomePaths;
                             info.calledInSomePaths = info.calledInEveryPaths = true;
                         }
                     }
-
                     if (info) {
                         if (duplicate) {
                             context.report({
@@ -405,7 +340,6 @@ module.exports = {
                     });
                 }
             },
-
             /**
              * Set the mark to the returned path as `super()` was called.
              * @param {ASTNode} node A ReturnStatement node to check.
@@ -415,25 +349,19 @@ module.exports = {
                 if (!(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends)) {
                     return;
                 }
-
                 // Skips if no argument.
                 if (!node.argument) {
                     return;
                 }
-
                 // Returning argument is a substitute of 'super()'.
                 const segments = funcInfo.currentSegments;
-
                 for (const segment of segments) {
-
                     if (segment.reachable) {
                         const info = segInfoMap[segment.id];
-
                         info.calledInSomePaths = info.calledInEveryPaths = true;
                     }
                 }
             },
-
             /**
              * Resets state.
              * @returns {void}
@@ -443,4 +371,4 @@ module.exports = {
             }
         };
     }
-};
+};

package/src/ui/extension/node_modules/eslint/lib/rules/curly.js

@@ -3,28 +3,22 @@
  * @author Nicholas C. Zakas
  */
 "use strict";
-
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
-
 const astUtils = require("./utils/ast-utils");
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
-
 /** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",
-
         docs: {
             description: "Enforce consistent brace style for all control statements",
             recommended: false,
             url: "https://eslint.org/docs/latest/rules/curly"
         },
-
         schema: {
             anyOf: [
                 {
@@ -52,9 +46,7 @@ module.exports = {
                 }
             ]
         },
-
         fixable: "code",
-
         messages: {
             missingCurlyAfter: "Expected { after '{{name}}'.",
             missingCurlyAfterCondition: "Expected { after '{{name}}' condition.",
@@ -62,20 +54,15 @@ module.exports = {
             unexpectedCurlyAfterCondition: "Unnecessary { after '{{name}}' condition."
         }
     },
-
-    create(context) {
-
+    create(_context) {
         const multiOnly = (context.options[0] === "multi");
         const multiLine = (context.options[0] === "multi-line");
         const multiOrNest = (context.options[0] === "multi-or-nest");
         const consistent = (context.options[1] === "consistent");
-
         const sourceCode = context.sourceCode;
-
         //--------------------------------------------------------------------------
         // Helpers
         //--------------------------------------------------------------------------
-
         /**
          * Determines if a given node is a one-liner that's on the same line as it's preceding code.
          * @param {ASTNode} node The node to check.
@@ -86,10 +73,8 @@ module.exports = {
             const before = sourceCode.getTokenBefore(node);
             const last = sourceCode.getLastToken(node);
             const lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
-
             return before.loc.start.line === lastExcludingSemicolon.loc.end.line;
         }
-
         /**
          * Determines if a given node is a one-liner.
          * @param {ASTNode} node The node to check.
@@ -100,14 +85,11 @@ module.exports = {
             if (node.type === "EmptyStatement") {
                 return true;
             }
-
             const first = sourceCode.getFirstToken(node);
             const last = sourceCode.getLastToken(node);
             const lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
-
             return first.loc.start.line === lastExcludingSemicolon.loc.end.line;
         }
-
         /**
          * Determines if the given node is a lexical declaration (let, const, function, or class)
          * @param {ASTNode} node The node to check
@@ -118,10 +100,8 @@ module.exports = {
             if (node.type === "VariableDeclaration") {
                 return node.kind === "const" || node.kind === "let";
             }
-
             return node.type === "FunctionDeclaration" || node.type === "ClassDeclaration";
         }
-
         /**
          * Checks if the given token is an `else` token or not.
          * @param {Token} token The token to check.
@@ -130,7 +110,6 @@ module.exports = {
         function isElseKeywordToken(token) {
             return token.value === "else" && token.type === "Keyword";
         }
-
         /**
          * Determines whether the given node has an `else` keyword token as the first token after.
          * @param {ASTNode} node The node to check.
@@ -138,10 +117,8 @@ module.exports = {
          */
         function isFollowedByElseKeyword(node) {
             const nextToken = sourceCode.getTokenAfter(node);
-
             return Boolean(nextToken) && isElseKeywordToken(nextToken);
         }
-
         /**
          * Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError.
          * @param {Token} closingBracket The } token
@@ -151,21 +128,15 @@ module.exports = {
             const tokenBefore = sourceCode.getTokenBefore(closingBracket);
             const tokenAfter = sourceCode.getTokenAfter(closingBracket);
             const lastBlockNode = sourceCode.getNodeByRangeIndex(tokenBefore.range[0]);
-
             if (astUtils.isSemicolonToken(tokenBefore)) {
-
                 // If the last statement already has a semicolon, don't add another one.
                 return false;
             }
-
             if (!tokenAfter) {
-
                 // If there are no statements after this block, there is no need to add a semicolon.
                 return false;
             }
-
             if (lastBlockNode.type === "BlockStatement" && lastBlockNode.parent.type !== "FunctionExpression" && lastBlockNode.parent.type !== "ArrowFunctionExpression") {
-
                 /*
                  * If the last node surrounded by curly brackets is a BlockStatement (other than a FunctionExpression or an ArrowFunctionExpression),
                  * don't insert a semicolon. Otherwise, the semicolon would be parsed as a separate statement, which would cause
@@ -173,29 +144,21 @@ module.exports = {
                  */
                 return false;
             }
-
             if (tokenBefore.loc.end.line === tokenAfter.loc.start.line) {
-
                 // If the next token is on the same line, insert a semicolon.
                 return true;
             }
-
             if (/^[([/`+-]/u.test(tokenAfter.value)) {
-
                 // If the next token starts with a character that would disrupt ASI, insert a semicolon.
                 return true;
             }
-
             if (tokenBefore.type === "Punctuator" && (tokenBefore.value === "++" || tokenBefore.value === "--")) {
-
                 // If the last token is ++ or --, insert a semicolon to avoid disrupting ASI.
                 return true;
             }
-
             // Otherwise, do not insert a semicolon.
             return false;
         }
-
         /**
          * Determines whether the code represented by the given node contains an `if` statement
          * that would become associated with an `else` keyword directly appended to that code.
@@ -264,7 +227,6 @@ module.exports = {
                     return false;
             }
         }
-
         /**
          * Determines whether the existing curly braces around the single statement are necessary to preserve the semantics of the code.
          * The braces, which make the given block body, are necessary in either of the following situations:
@@ -295,11 +257,9 @@ module.exports = {
          */
         function areBracesNecessary(node) {
             const statement = node.body[0];
-
             return isLexicalDeclaration(statement) ||
                 hasUnsafeIf(statement) && isFollowedByElseKeyword(node);
         }
-
         /**
          * Prepares to check the body of a node to see if it's a block statement.
          * @param {ASTNode} node The node to report if there's a problem.
@@ -317,7 +277,6 @@ module.exports = {
         function prepareCheck(node, body, name, opts) {
             const hasBlock = (body.type === "BlockStatement");
             let expected = null;
-
             if (hasBlock && (body.body.length !== 1 || areBracesNecessary(body))) {
                 expected = true;
             } else if (multiOnly) {
@@ -326,24 +285,19 @@ module.exports = {
                 if (!isCollapsedOneLiner(body)) {
                     expected = true;
                 }
-
                 // otherwise, the body is allowed to have braces or not to have braces
-
             } else if (multiOrNest) {
                 if (hasBlock) {
                     const statement = body.body[0];
                     const leadingCommentsInBlock = sourceCode.getCommentsBefore(statement);
-
                     expected = !isOneLiner(statement) || leadingCommentsInBlock.length > 0;
                 } else {
                     expected = !isOneLiner(body);
                 }
             } else {
-
                 // default "all"
                 expected = true;
             }
-
             return {
                 actual: hasBlock,
                 expected,
@@ -368,7 +322,6 @@ module.exports = {
                                     name
                                 },
                                 fix(fixer) {
-
                                     /*
                                      * `do while` expressions sometimes need a space to be inserted after `do`.
                                      * e.g. `do{foo()} while (bar)` should be corrected to `do foo() while (bar)`
@@ -376,24 +329,19 @@ module.exports = {
                                     const needsPrecedingSpace = node.type === "DoWhileStatement" &&
                                         sourceCode.getTokenBefore(body).range[1] === body.range[0] &&
                                         !astUtils.canTokensBeAdjacent("do", sourceCode.getFirstToken(body, { skip: 1 }));
-
                                     const openingBracket = sourceCode.getFirstToken(body);
                                     const closingBracket = sourceCode.getLastToken(body);
                                     const lastTokenInBlock = sourceCode.getTokenBefore(closingBracket);
-
                                     if (needsSemicolon(closingBracket)) {
-
                                         /*
                                          * If removing braces would cause a SyntaxError due to multiple statements on the same line (or
                                          * change the semantics of the code due to ASI), don't perform a fix.
                                          */
                                         return null;
                                     }
-
                                     const resultingBodyText = sourceCode.getText().slice(openingBracket.range[1], lastTokenInBlock.range[0]) +
                                         sourceCode.getText(lastTokenInBlock) +
                                         sourceCode.getText().slice(lastTokenInBlock.range[1], closingBracket.range[0]);
-
                                     return fixer.replaceText(body, (needsPrecedingSpace ? " " : "") + resultingBodyText);
                                 }
                             });
@@ -402,7 +350,6 @@ module.exports = {
                 }
             };
         }
-
         /**
          * Prepares to check the bodies of a "if", "else if" and "else" chain.
          * @param {ASTNode} node The first IfStatement node of the chain.
@@ -411,7 +358,6 @@ module.exports = {
          */
         function prepareIfChecks(node) {
             const preparedChecks = [];
-
             for (let currentNode = node; currentNode; currentNode = currentNode.alternate) {
                 preparedChecks.push(prepareCheck(currentNode, currentNode.consequent, "if", { condition: true }));
                 if (currentNode.alternate && currentNode.alternate.type !== "IfStatement") {
@@ -419,9 +365,7 @@ module.exports = {
                     break;
                 }
             }
-
             if (consistent) {
-
                 /*
                  * If any node should have or already have braces, make sure they
                  * all have braces.
@@ -433,54 +377,42 @@ module.exports = {
                     }
                     return preparedCheck.actual;
                 });
-
                 preparedChecks.forEach(preparedCheck => {
                     preparedCheck.expected = expected;
                 });
             }
-
             return preparedChecks;
         }
-
         //--------------------------------------------------------------------------
         // Public
         //--------------------------------------------------------------------------
-
         return {
             IfStatement(node) {
                 const parent = node.parent;
                 const isElseIf = parent.type === "IfStatement" && parent.alternate === node;
-
                 if (!isElseIf) {
-
                     // This is a top `if`, check the whole `if-else-if` chain
                     prepareIfChecks(node).forEach(preparedCheck => {
                         preparedCheck.check();
                     });
                 }
-
                 // Skip `else if`, it's already checked (when the top `if` was visited)
             },
-
             WhileStatement(node) {
                 prepareCheck(node, node.body, "while", { condition: true }).check();
             },
-
             DoWhileStatement(node) {
                 prepareCheck(node, node.body, "do").check();
             },
-
             ForStatement(node) {
                 prepareCheck(node, node.body, "for", { condition: true }).check();
             },
-
             ForInStatement(node) {
                 prepareCheck(node, node.body, "for-in").check();
             },
-
             ForOfStatement(node) {
                 prepareCheck(node, node.body, "for-of").check();
             }
         };
     }
-};
+};