{"files":[{"status":"M","path":"packages\/eslint-plugin-react-hooks\/__tests__\/ESLintRulesOfHooks-test.js"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/LICENSE"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/README.md"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/assert.js"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-analyzer.js"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-segment.js"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-state.js"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path.js"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/fork-context.js"},{"status":"A","path":"packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/id-generator.js"},{"status":"M","path":"packages\/eslint-plugin-react-hooks\/src\/rules\/RulesOfHooks.ts"}],"patch":"diff --git a\/packages\/eslint-plugin-react-hooks\/__tests__\/ESLintRulesOfHooks-test.js b\/packages\/eslint-plugin-react-hooks\/__tests__\/ESLintRulesOfHooks-test.js\nindex b8ec97678a..22d2427de6 100644\n--- a\/packages\/eslint-plugin-react-hooks\/__tests__\/ESLintRulesOfHooks-test.js\n+++ b\/packages\/eslint-plugin-react-hooks\/__tests__\/ESLintRulesOfHooks-test.js\n@@ -34,7 +34,7 @@ function normalizeIndent(strings) {\n \/\/ }\n \/\/ ***************************************************\n \n-const tests = {\n+const allTests = {\n valid: [\n {\n code: normalizeIndent`\n@@ -44,6 +44,25 @@ const tests = {\n }\n `,\n },\n+ {\n+ syntax: 'flow',\n+ code: normalizeIndent`\n+ \/\/ Component syntax\n+ component Button() {\n+ useHook();\n+ return

Button!<\/div>;\n+ }\n+ `,\n+ },\n+ {\n+ syntax: 'flow',\n+ code: normalizeIndent`\n+ \/\/ Hook syntax\n+ hook useSampleHook() {\n+ useHook();\n+ }\n+ `,\n+ },\n {\n code: normalizeIndent`\n \/\/ Valid because components can use hooks.\n@@ -563,6 +582,28 @@ const tests = {\n },\n ],\n invalid: [\n+ {\n+ syntax: 'flow',\n+ code: normalizeIndent`\n+ component Button(cond: boolean) {\n+ if (cond) {\n+ useConditionalHook();\n+ }\n+ }\n+ `,\n+ errors: [conditionalError('useConditionalHook')],\n+ },\n+ {\n+ syntax: 'flow',\n+ code: normalizeIndent`\n+ hook useTest(cond: boolean) {\n+ if (cond) {\n+ useConditionalHook();\n+ }\n+ }\n+ `,\n+ errors: [conditionalError('useConditionalHook')],\n+ },\n {\n code: normalizeIndent`\n \/\/ Invalid because it's dangerous and might not warn otherwise.\n@@ -1287,8 +1328,8 @@ const tests = {\n };\n \n if (__EXPERIMENTAL__) {\n- tests.valid = [\n- ...tests.valid,\n+ allTests.valid = [\n+ ...allTests.valid,\n {\n code: normalizeIndent`\n \/\/ Valid because functions created with useEffectEvent can be called in a useEffect.\n@@ -1385,8 +1426,8 @@ if (__EXPERIMENTAL__) {\n `,\n },\n ];\n- tests.invalid = [\n- ...tests.invalid,\n+ allTests.invalid = [\n+ ...allTests.invalid,\n {\n code: normalizeIndent`\n function MyComponent({ theme }) {\n@@ -1536,7 +1577,7 @@ function asyncComponentHookError(fn) {\n if (!process.env.CI) {\n let only = [];\n let skipped = [];\n- [...tests.valid, ...tests.invalid].forEach(t => {\n+ [...allTests.valid, ...allTests.invalid].forEach(t => {\n if (t.skip) {\n delete t.skip;\n skipped.push(t);\n@@ -1555,10 +1596,23 @@ if (!process.env.CI) {\n }\n return true;\n };\n- tests.valid = tests.valid.filter(predicate);\n- tests.invalid = tests.invalid.filter(predicate);\n+ allTests.valid = allTests.valid.filter(predicate);\n+ allTests.invalid = allTests.invalid.filter(predicate);\n+}\n+\n+function filteredTests(predicate) {\n+ return {\n+ valid: allTests.valid.filter(predicate),\n+ invalid: allTests.invalid.filter(predicate),\n+ };\n }\n \n+const flowTests = filteredTests(t => t.syntax == null || t.syntax === 'flow');\n+const tests = filteredTests(t => t.syntax !== 'flow');\n+\n+allTests.valid.forEach(t => delete t.syntax);\n+allTests.invalid.forEach(t => delete t.syntax);\n+\n describe('rules-of-hooks\/rules-of-hooks', () => {\n const parserOptionsV7 = {\n ecmaFeatures: {\n@@ -1594,6 +1648,25 @@ describe('rules-of-hooks\/rules-of-hooks', () => {\n tests\n );\n \n+ new ESLintTesterV7({\n+ parser: require.resolve('hermes-eslint'),\n+ parserOptions: {\n+ sourceType: 'module',\n+ enableExperimentalComponentSyntax: true,\n+ },\n+ }).run('eslint: v7, parser: hermes-eslint', ReactHooksESLintRule, flowTests);\n+\n+ new ESLintTesterV9({\n+ languageOptions: {\n+ ...languageOptionsV9,\n+ parser: require('hermes-eslint'),\n+ parserOptions: {\n+ sourceType: 'module',\n+ enableExperimentalComponentSyntax: true,\n+ },\n+ },\n+ }).run('eslint: v9, parser: hermes-eslint', ReactHooksESLintRule, flowTests);\n+\n new ESLintTesterV7({\n parser: require.resolve('@typescript-eslint\/parser-v2'),\n parserOptions: parserOptionsV7,\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/LICENSE b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/LICENSE\nnew file mode 100644\nindex 0000000000..b607bb36e9\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/LICENSE\n@@ -0,0 +1,19 @@\n+Copyright OpenJS Foundation and other contributors, \n+\n+Permission is hereby granted, free of charge, to any person obtaining a copy\n+of this software and associated documentation files (the \"Software\"), to deal\n+in the Software without restriction, including without limitation the rights\n+to use, copy, modify, merge, publish, distribute, sublicense, and\/or sell\n+copies of the Software, and to permit persons to whom the Software is\n+furnished to do so, subject to the following conditions:\n+\n+The above copyright notice and this permission notice shall be included in\n+all copies or substantial portions of the Software.\n+\n+THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n+THE SOFTWARE.\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/README.md b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/README.md\nnew file mode 100644\nindex 0000000000..1109cb2f38\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/README.md\n@@ -0,0 +1,6 @@\n+# Code Path Analyzer\n+\n+This code is a forked version of ESLints Code Path Analyzer which includes\n+support for Component Syntax.\n+\n+Forked from: https:\/\/github.com\/eslint\/eslint\/tree\/main\/lib\/linter\/code-path-analysis\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/assert.js b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/assert.js\nnew file mode 100644\nindex 0000000000..d6dc3539f3\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/assert.js\n@@ -0,0 +1,9 @@\n+'use strict';\n+\n+function assert(cond) {\n+ if (!cond) {\n+ throw new Error('Assertion violated.');\n+ }\n+}\n+\n+module.exports = assert;\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-analyzer.js b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-analyzer.js\nnew file mode 100644\nindex 0000000000..8dd76e5712\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-analyzer.js\n@@ -0,0 +1,802 @@\n+'use strict';\n+\n+\/* eslint-disable react-internal\/no-primitive-constructors *\/\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Requirements\n+\/\/------------------------------------------------------------------------------\n+\n+\/\/ eslint-disable-next-line\n+const assert = require('.\/assert');\n+\/\/ eslint-disable-next-line\n+const CodePath = require('.\/code-path');\n+\/\/ eslint-disable-next-line\n+const CodePathSegment = require('.\/code-path-segment');\n+\/\/ eslint-disable-next-line\n+const IdGenerator = require('.\/id-generator');\n+\n+const breakableTypePattern =\n+ \/^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$\/u;\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Helpers\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * Checks whether or not a given node is a `case` node (not `default` node).\n+ * @param {ASTNode} node A `SwitchCase` node to check.\n+ * @returns {boolean} `true` if the node is a `case` node (not `default` node).\n+ *\/\n+function isCaseNode(node) {\n+ return Boolean(node.test);\n+}\n+\n+\/**\n+ * Checks if a given node appears as the value of a PropertyDefinition node.\n+ * @param {ASTNode} node THe node to check.\n+ * @returns {boolean} `true` if the node is a PropertyDefinition value,\n+ * false if not.\n+ *\/\n+function isPropertyDefinitionValue(node) {\n+ const parent = node.parent;\n+\n+ return (\n+ parent && parent.type === 'PropertyDefinition' && parent.value === node\n+ );\n+}\n+\n+\/**\n+ * Checks whether the given logical operator is taken into account for the code\n+ * path analysis.\n+ * @param {string} operator The operator found in the LogicalExpression node\n+ * @returns {boolean} `true` if the operator is \"&&\" or \"||\" or \"??\"\n+ *\/\n+function isHandledLogicalOperator(operator) {\n+ return operator === '&&' || operator === '||' || operator === '??';\n+}\n+\n+\/**\n+ * Checks whether the given assignment operator is a logical assignment operator.\n+ * Logical assignments are taken into account for the code path analysis\n+ * because of their short-circuiting semantics.\n+ * @param {string} operator The operator found in the AssignmentExpression node\n+ * @returns {boolean} `true` if the operator is \"&&=\" or \"||=\" or \"??=\"\n+ *\/\n+function isLogicalAssignmentOperator(operator) {\n+ return operator === '&&=' || operator === '||=' || operator === '??=';\n+}\n+\n+\/**\n+ * Gets the label if the parent node of a given node is a LabeledStatement.\n+ * @param {ASTNode} node A node to get.\n+ * @returns {string|null} The label or `null`.\n+ *\/\n+function getLabel(node) {\n+ if (node.parent.type === 'LabeledStatement') {\n+ return node.parent.label.name;\n+ }\n+ return null;\n+}\n+\n+\/**\n+ * Checks whether or not a given logical expression node goes different path\n+ * between the `true` case and the `false` case.\n+ * @param {ASTNode} node A node to check.\n+ * @returns {boolean} `true` if the node is a test of a choice statement.\n+ *\/\n+function isForkingByTrueOrFalse(node) {\n+ const parent = node.parent;\n+\n+ switch (parent.type) {\n+ case 'ConditionalExpression':\n+ case 'IfStatement':\n+ case 'WhileStatement':\n+ case 'DoWhileStatement':\n+ case 'ForStatement':\n+ return parent.test === node;\n+\n+ case 'LogicalExpression':\n+ return isHandledLogicalOperator(parent.operator);\n+\n+ case 'AssignmentExpression':\n+ return isLogicalAssignmentOperator(parent.operator);\n+\n+ default:\n+ return false;\n+ }\n+}\n+\n+\/**\n+ * Gets the boolean value of a given literal node.\n+ *\n+ * This is used to detect infinity loops (e.g. `while (true) {}`).\n+ * Statements preceded by an infinity loop are unreachable if the loop didn't\n+ * have any `break` statement.\n+ * @param {ASTNode} node A node to get.\n+ * @returns {boolean|undefined} a boolean value if the node is a Literal node,\n+ * otherwise `undefined`.\n+ *\/\n+function getBooleanValueIfSimpleConstant(node) {\n+ if (node.type === 'Literal') {\n+ return Boolean(node.value);\n+ }\n+ return void 0;\n+}\n+\n+\/**\n+ * Checks that a given identifier node is a reference or not.\n+ *\n+ * This is used to detect the first throwable node in a `try` block.\n+ * @param {ASTNode} node An Identifier node to check.\n+ * @returns {boolean} `true` if the node is a reference.\n+ *\/\n+function isIdentifierReference(node) {\n+ const parent = node.parent;\n+\n+ switch (parent.type) {\n+ case 'LabeledStatement':\n+ case 'BreakStatement':\n+ case 'ContinueStatement':\n+ case 'ArrayPattern':\n+ case 'RestElement':\n+ case 'ImportSpecifier':\n+ case 'ImportDefaultSpecifier':\n+ case 'ImportNamespaceSpecifier':\n+ case 'CatchClause':\n+ return false;\n+\n+ case 'FunctionDeclaration':\n+ case 'ComponentDeclaration':\n+ case 'HookDeclaration':\n+ case 'FunctionExpression':\n+ case 'ArrowFunctionExpression':\n+ case 'ClassDeclaration':\n+ case 'ClassExpression':\n+ case 'VariableDeclarator':\n+ return parent.id !== node;\n+\n+ case 'Property':\n+ case 'PropertyDefinition':\n+ case 'MethodDefinition':\n+ return parent.key !== node || parent.computed || parent.shorthand;\n+\n+ case 'AssignmentPattern':\n+ return parent.key !== node;\n+\n+ default:\n+ return true;\n+ }\n+}\n+\n+\/**\n+ * Updates the current segment with the head segment.\n+ * This is similar to local branches and tracking branches of git.\n+ *\n+ * To separate the current and the head is in order to not make useless segments.\n+ *\n+ * In this process, both \"onCodePathSegmentStart\" and \"onCodePathSegmentEnd\"\n+ * events are fired.\n+ * @param {CodePathAnalyzer} analyzer The instance.\n+ * @param {ASTNode} node The current AST node.\n+ * @returns {void}\n+ *\/\n+function forwardCurrentToHead(analyzer, node) {\n+ const codePath = analyzer.codePath;\n+ const state = CodePath.getState(codePath);\n+ const currentSegments = state.currentSegments;\n+ const headSegments = state.headSegments;\n+ const end = Math.max(currentSegments.length, headSegments.length);\n+ let i, currentSegment, headSegment;\n+\n+ \/\/ Fires leaving events.\n+ for (i = 0; i < end; ++i) {\n+ currentSegment = currentSegments[i];\n+ headSegment = headSegments[i];\n+\n+ if (currentSegment !== headSegment && currentSegment) {\n+ if (currentSegment.reachable) {\n+ analyzer.emitter.emit('onCodePathSegmentEnd', currentSegment, node);\n+ }\n+ }\n+ }\n+\n+ \/\/ Update state.\n+ state.currentSegments = headSegments;\n+\n+ \/\/ Fires entering events.\n+ for (i = 0; i < end; ++i) {\n+ currentSegment = currentSegments[i];\n+ headSegment = headSegments[i];\n+\n+ if (currentSegment !== headSegment && headSegment) {\n+ CodePathSegment.markUsed(headSegment);\n+ if (headSegment.reachable) {\n+ analyzer.emitter.emit('onCodePathSegmentStart', headSegment, node);\n+ }\n+ }\n+ }\n+}\n+\n+\/**\n+ * Updates the current segment with empty.\n+ * This is called at the last of functions or the program.\n+ * @param {CodePathAnalyzer} analyzer The instance.\n+ * @param {ASTNode} node The current AST node.\n+ * @returns {void}\n+ *\/\n+function leaveFromCurrentSegment(analyzer, node) {\n+ const state = CodePath.getState(analyzer.codePath);\n+ const currentSegments = state.currentSegments;\n+\n+ for (let i = 0; i < currentSegments.length; ++i) {\n+ const currentSegment = currentSegments[i];\n+ if (currentSegment.reachable) {\n+ analyzer.emitter.emit('onCodePathSegmentEnd', currentSegment, node);\n+ }\n+ }\n+\n+ state.currentSegments = [];\n+}\n+\n+\/**\n+ * Updates the code path due to the position of a given node in the parent node\n+ * thereof.\n+ *\n+ * For example, if the node is `parent.consequent`, this creates a fork from the\n+ * current path.\n+ * @param {CodePathAnalyzer} analyzer The instance.\n+ * @param {ASTNode} node The current AST node.\n+ * @returns {void}\n+ *\/\n+function preprocess(analyzer, node) {\n+ const codePath = analyzer.codePath;\n+ const state = CodePath.getState(codePath);\n+ const parent = node.parent;\n+\n+ switch (parent.type) {\n+ \/\/ The `arguments.length == 0` case is in `postprocess` function.\n+ case 'CallExpression':\n+ if (\n+ parent.optional === true &&\n+ parent.arguments.length >= 1 &&\n+ parent.arguments[0] === node\n+ ) {\n+ state.makeOptionalRight();\n+ }\n+ break;\n+ case 'MemberExpression':\n+ if (parent.optional === true && parent.property === node) {\n+ state.makeOptionalRight();\n+ }\n+ break;\n+\n+ case 'LogicalExpression':\n+ if (parent.right === node && isHandledLogicalOperator(parent.operator)) {\n+ state.makeLogicalRight();\n+ }\n+ break;\n+\n+ case 'AssignmentExpression':\n+ if (\n+ parent.right === node &&\n+ isLogicalAssignmentOperator(parent.operator)\n+ ) {\n+ state.makeLogicalRight();\n+ }\n+ break;\n+\n+ case 'ConditionalExpression':\n+ case 'IfStatement':\n+ \/*\n+ * Fork if this node is at `consequent`\/`alternate`.\n+ * `popForkContext()` exists at `IfStatement:exit` and\n+ * `ConditionalExpression:exit`.\n+ *\/\n+ if (parent.consequent === node) {\n+ state.makeIfConsequent();\n+ } else if (parent.alternate === node) {\n+ state.makeIfAlternate();\n+ }\n+ break;\n+\n+ case 'SwitchCase':\n+ if (parent.consequent[0] === node) {\n+ state.makeSwitchCaseBody(false, !parent.test);\n+ }\n+ break;\n+\n+ case 'TryStatement':\n+ if (parent.handler === node) {\n+ state.makeCatchBlock();\n+ } else if (parent.finalizer === node) {\n+ state.makeFinallyBlock();\n+ }\n+ break;\n+\n+ case 'WhileStatement':\n+ if (parent.test === node) {\n+ state.makeWhileTest(getBooleanValueIfSimpleConstant(node));\n+ } else {\n+ assert(parent.body === node);\n+ state.makeWhileBody();\n+ }\n+ break;\n+\n+ case 'DoWhileStatement':\n+ if (parent.body === node) {\n+ state.makeDoWhileBody();\n+ } else {\n+ assert(parent.test === node);\n+ state.makeDoWhileTest(getBooleanValueIfSimpleConstant(node));\n+ }\n+ break;\n+\n+ case 'ForStatement':\n+ if (parent.test === node) {\n+ state.makeForTest(getBooleanValueIfSimpleConstant(node));\n+ } else if (parent.update === node) {\n+ state.makeForUpdate();\n+ } else if (parent.body === node) {\n+ state.makeForBody();\n+ }\n+ break;\n+\n+ case 'ForInStatement':\n+ case 'ForOfStatement':\n+ if (parent.left === node) {\n+ state.makeForInOfLeft();\n+ } else if (parent.right === node) {\n+ state.makeForInOfRight();\n+ } else {\n+ assert(parent.body === node);\n+ state.makeForInOfBody();\n+ }\n+ break;\n+\n+ case 'AssignmentPattern':\n+ \/*\n+ * Fork if this node is at `right`.\n+ * `left` is executed always, so it uses the current path.\n+ * `popForkContext()` exists at `AssignmentPattern:exit`.\n+ *\/\n+ if (parent.right === node) {\n+ state.pushForkContext();\n+ state.forkBypassPath();\n+ state.forkPath();\n+ }\n+ break;\n+\n+ default:\n+ break;\n+ }\n+}\n+\n+\/**\n+ * Updates the code path due to the type of a given node in entering.\n+ * @param {CodePathAnalyzer} analyzer The instance.\n+ * @param {ASTNode} node The current AST node.\n+ * @returns {void}\n+ *\/\n+function processCodePathToEnter(analyzer, node) {\n+ let codePath = analyzer.codePath;\n+ let state = codePath && CodePath.getState(codePath);\n+ const parent = node.parent;\n+\n+ \/**\n+ * Creates a new code path and trigger the onCodePathStart event\n+ * based on the currently selected node.\n+ * @param {string} origin The reason the code path was started.\n+ * @returns {void}\n+ *\/\n+ function startCodePath(origin) {\n+ if (codePath) {\n+ \/\/ Emits onCodePathSegmentStart events if updated.\n+ forwardCurrentToHead(analyzer, node);\n+ }\n+\n+ \/\/ Create the code path of this scope.\n+ codePath = analyzer.codePath = new CodePath({\n+ id: analyzer.idGenerator.next(),\n+ origin,\n+ upper: codePath,\n+ onLooped: analyzer.onLooped,\n+ });\n+ state = CodePath.getState(codePath);\n+\n+ \/\/ Emits onCodePathStart events.\n+ analyzer.emitter.emit('onCodePathStart', codePath, node);\n+ }\n+\n+ \/*\n+ * Special case: The right side of class field initializer is considered\n+ * to be its own function, so we need to start a new code path in this\n+ * case.\n+ *\/\n+ if (isPropertyDefinitionValue(node)) {\n+ startCodePath('class-field-initializer');\n+\n+ \/*\n+ * Intentional fall through because `node` needs to also be\n+ * processed by the code below. For example, if we have:\n+ *\n+ * class Foo {\n+ * a = () => {}\n+ * }\n+ *\n+ * In this case, we also need start a second code path.\n+ *\/\n+ }\n+\n+ switch (node.type) {\n+ case 'Program':\n+ startCodePath('program');\n+ break;\n+\n+ case 'FunctionDeclaration':\n+ case 'ComponentDeclaration':\n+ case 'HookDeclaration':\n+ case 'FunctionExpression':\n+ case 'ArrowFunctionExpression':\n+ startCodePath('function');\n+ break;\n+\n+ case 'StaticBlock':\n+ startCodePath('class-static-block');\n+ break;\n+\n+ case 'ChainExpression':\n+ state.pushChainContext();\n+ break;\n+ case 'CallExpression':\n+ if (node.optional === true) {\n+ state.makeOptionalNode();\n+ }\n+ break;\n+ case 'MemberExpression':\n+ if (node.optional === true) {\n+ state.makeOptionalNode();\n+ }\n+ break;\n+\n+ case 'LogicalExpression':\n+ if (isHandledLogicalOperator(node.operator)) {\n+ state.pushChoiceContext(node.operator, isForkingByTrueOrFalse(node));\n+ }\n+ break;\n+\n+ case 'AssignmentExpression':\n+ if (isLogicalAssignmentOperator(node.operator)) {\n+ state.pushChoiceContext(\n+ node.operator.slice(0, -1), \/\/ removes `=` from the end\n+ isForkingByTrueOrFalse(node),\n+ );\n+ }\n+ break;\n+\n+ case 'ConditionalExpression':\n+ case 'IfStatement':\n+ state.pushChoiceContext('test', false);\n+ break;\n+\n+ case 'SwitchStatement':\n+ state.pushSwitchContext(node.cases.some(isCaseNode), getLabel(node));\n+ break;\n+\n+ case 'TryStatement':\n+ state.pushTryContext(Boolean(node.finalizer));\n+ break;\n+\n+ case 'SwitchCase':\n+ \/*\n+ * Fork if this node is after the 2st node in `cases`.\n+ * It's similar to `else` blocks.\n+ * The next `test` node is processed in this path.\n+ *\/\n+ if (parent.discriminant !== node && parent.cases[0] !== node) {\n+ state.forkPath();\n+ }\n+ break;\n+\n+ case 'WhileStatement':\n+ case 'DoWhileStatement':\n+ case 'ForStatement':\n+ case 'ForInStatement':\n+ case 'ForOfStatement':\n+ state.pushLoopContext(node.type, getLabel(node));\n+ break;\n+\n+ case 'LabeledStatement':\n+ if (!breakableTypePattern.test(node.body.type)) {\n+ state.pushBreakContext(false, node.label.name);\n+ }\n+ break;\n+\n+ default:\n+ break;\n+ }\n+\n+ \/\/ Emits onCodePathSegmentStart events if updated.\n+ forwardCurrentToHead(analyzer, node);\n+}\n+\n+\/**\n+ * Updates the code path due to the type of a given node in leaving.\n+ * @param {CodePathAnalyzer} analyzer The instance.\n+ * @param {ASTNode} node The current AST node.\n+ * @returns {void}\n+ *\/\n+function processCodePathToExit(analyzer, node) {\n+ const codePath = analyzer.codePath;\n+ const state = CodePath.getState(codePath);\n+ let dontForward = false;\n+\n+ switch (node.type) {\n+ case 'ChainExpression':\n+ state.popChainContext();\n+ break;\n+\n+ case 'IfStatement':\n+ case 'ConditionalExpression':\n+ state.popChoiceContext();\n+ break;\n+\n+ case 'LogicalExpression':\n+ if (isHandledLogicalOperator(node.operator)) {\n+ state.popChoiceContext();\n+ }\n+ break;\n+\n+ case 'AssignmentExpression':\n+ if (isLogicalAssignmentOperator(node.operator)) {\n+ state.popChoiceContext();\n+ }\n+ break;\n+\n+ case 'SwitchStatement':\n+ state.popSwitchContext();\n+ break;\n+\n+ case 'SwitchCase':\n+ \/*\n+ * This is the same as the process at the 1st `consequent` node in\n+ * `preprocess` function.\n+ * Must do if this `consequent` is empty.\n+ *\/\n+ if (node.consequent.length === 0) {\n+ state.makeSwitchCaseBody(true, !node.test);\n+ }\n+ if (state.forkContext.reachable) {\n+ dontForward = true;\n+ }\n+ break;\n+\n+ case 'TryStatement':\n+ state.popTryContext();\n+ break;\n+\n+ case 'BreakStatement':\n+ forwardCurrentToHead(analyzer, node);\n+ state.makeBreak(node.label && node.label.name);\n+ dontForward = true;\n+ break;\n+\n+ case 'ContinueStatement':\n+ forwardCurrentToHead(analyzer, node);\n+ state.makeContinue(node.label && node.label.name);\n+ dontForward = true;\n+ break;\n+\n+ case 'ReturnStatement':\n+ forwardCurrentToHead(analyzer, node);\n+ state.makeReturn();\n+ dontForward = true;\n+ break;\n+\n+ case 'ThrowStatement':\n+ forwardCurrentToHead(analyzer, node);\n+ state.makeThrow();\n+ dontForward = true;\n+ break;\n+\n+ case 'Identifier':\n+ if (isIdentifierReference(node)) {\n+ state.makeFirstThrowablePathInTryBlock();\n+ dontForward = true;\n+ }\n+ break;\n+\n+ case 'CallExpression':\n+ case 'ImportExpression':\n+ case 'MemberExpression':\n+ case 'NewExpression':\n+ case 'YieldExpression':\n+ state.makeFirstThrowablePathInTryBlock();\n+ break;\n+\n+ case 'WhileStatement':\n+ case 'DoWhileStatement':\n+ case 'ForStatement':\n+ case 'ForInStatement':\n+ case 'ForOfStatement':\n+ state.popLoopContext();\n+ break;\n+\n+ case 'AssignmentPattern':\n+ state.popForkContext();\n+ break;\n+\n+ case 'LabeledStatement':\n+ if (!breakableTypePattern.test(node.body.type)) {\n+ state.popBreakContext();\n+ }\n+ break;\n+\n+ default:\n+ break;\n+ }\n+\n+ \/\/ Emits onCodePathSegmentStart events if updated.\n+ if (!dontForward) {\n+ forwardCurrentToHead(analyzer, node);\n+ }\n+}\n+\n+\/**\n+ * Updates the code path to finalize the current code path.\n+ * @param {CodePathAnalyzer} analyzer The instance.\n+ * @param {ASTNode} node The current AST node.\n+ * @returns {void}\n+ *\/\n+function postprocess(analyzer, node) {\n+ \/**\n+ * Ends the code path for the current node.\n+ * @returns {void}\n+ *\/\n+ function endCodePath() {\n+ let codePath = analyzer.codePath;\n+\n+ \/\/ Mark the current path as the final node.\n+ CodePath.getState(codePath).makeFinal();\n+\n+ \/\/ Emits onCodePathSegmentEnd event of the current segments.\n+ leaveFromCurrentSegment(analyzer, node);\n+\n+ \/\/ Emits onCodePathEnd event of this code path.\n+ analyzer.emitter.emit('onCodePathEnd', codePath, node);\n+\n+ codePath = analyzer.codePath = analyzer.codePath.upper;\n+ }\n+\n+ switch (node.type) {\n+ case 'Program':\n+ case 'FunctionDeclaration':\n+ case 'ComponentDeclaration':\n+ case 'HookDeclaration':\n+ case 'FunctionExpression':\n+ case 'ArrowFunctionExpression':\n+ case 'StaticBlock': {\n+ endCodePath();\n+ break;\n+ }\n+\n+ \/\/ The `arguments.length >= 1` case is in `preprocess` function.\n+ case 'CallExpression':\n+ if (node.optional === true && node.arguments.length === 0) {\n+ CodePath.getState(analyzer.codePath).makeOptionalRight();\n+ }\n+ break;\n+\n+ default:\n+ break;\n+ }\n+\n+ \/*\n+ * Special case: The right side of class field initializer is considered\n+ * to be its own function, so we need to end a code path in this\n+ * case.\n+ *\n+ * We need to check after the other checks in order to close the\n+ * code paths in the correct order for code like this:\n+ *\n+ *\n+ * class Foo {\n+ * a = () => {}\n+ * }\n+ *\n+ * In this case, The ArrowFunctionExpression code path is closed first\n+ * and then we need to close the code path for the PropertyDefinition\n+ * value.\n+ *\/\n+ if (isPropertyDefinitionValue(node)) {\n+ endCodePath();\n+ }\n+}\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Public Interface\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * The class to analyze code paths.\n+ * This class implements the EventGenerator interface.\n+ *\/\n+class CodePathAnalyzer {\n+ \/**\n+ * @param {EventGenerator} eventGenerator An event generator to wrap.\n+ *\/\n+ constructor(emitters) {\n+ this.emitter = {\n+ emit(event, ...args) {\n+ emitters[event]?.(...args);\n+ },\n+ };\n+ this.codePath = null;\n+ this.idGenerator = new IdGenerator('s');\n+ this.currentNode = null;\n+ this.onLooped = this.onLooped.bind(this);\n+ }\n+\n+ \/**\n+ * Does the process to enter a given AST node.\n+ * This updates state of analysis and calls `enterNode` of the wrapped.\n+ * @param {ASTNode} node A node which is entering.\n+ * @returns {void}\n+ *\/\n+ enterNode(node) {\n+ this.currentNode = node;\n+\n+ \/\/ Updates the code path due to node's position in its parent node.\n+ if (node.parent) {\n+ preprocess(this, node);\n+ }\n+\n+ \/*\n+ * Updates the code path.\n+ * And emits onCodePathStart\/onCodePathSegmentStart events.\n+ *\/\n+ processCodePathToEnter(this, node);\n+\n+ this.currentNode = null;\n+ }\n+\n+ \/**\n+ * Does the process to leave a given AST node.\n+ * This updates state of analysis and calls `leaveNode` of the wrapped.\n+ * @param {ASTNode} node A node which is leaving.\n+ * @returns {void}\n+ *\/\n+ leaveNode(node) {\n+ this.currentNode = node;\n+\n+ \/*\n+ * Updates the code path.\n+ * And emits onCodePathStart\/onCodePathSegmentStart events.\n+ *\/\n+ processCodePathToExit(this, node);\n+\n+ \/\/ Emits the last onCodePathStart\/onCodePathSegmentStart events.\n+ postprocess(this, node);\n+\n+ this.currentNode = null;\n+ }\n+\n+ \/**\n+ * This is called on a code path looped.\n+ * Then this raises a looped event.\n+ * @param {CodePathSegment} fromSegment A segment of prev.\n+ * @param {CodePathSegment} toSegment A segment of next.\n+ * @returns {void}\n+ *\/\n+ onLooped(fromSegment, toSegment) {\n+ if (fromSegment.reachable && toSegment.reachable) {\n+ this.emitter.emit(\n+ 'onCodePathSegmentLoop',\n+ fromSegment,\n+ toSegment,\n+ this.currentNode,\n+ );\n+ }\n+ }\n+}\n+\n+module.exports = CodePathAnalyzer;\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-segment.js b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-segment.js\nnew file mode 100644\nindex 0000000000..fb015296a7\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-segment.js\n@@ -0,0 +1,225 @@\n+'use strict';\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Requirements\n+\/\/------------------------------------------------------------------------------\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Helpers\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * Checks whether or not a given segment is reachable.\n+ * @param {CodePathSegment} segment A segment to check.\n+ * @returns {boolean} `true` if the segment is reachable.\n+ *\/\n+function isReachable(segment) {\n+ return segment.reachable;\n+}\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Public Interface\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * A code path segment.\n+ *\/\n+class CodePathSegment {\n+ \/**\n+ * @param {string} id An identifier.\n+ * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n+ * This array includes unreachable segments.\n+ * @param {boolean} reachable A flag which shows this is reachable.\n+ *\/\n+ constructor(id, allPrevSegments, reachable) {\n+ \/**\n+ * The identifier of this code path.\n+ * Rules use it to store additional information of each rule.\n+ * @type {string}\n+ *\/\n+ this.id = id;\n+\n+ \/**\n+ * An array of the next segments.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ this.nextSegments = [];\n+\n+ \/**\n+ * An array of the previous segments.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ this.prevSegments = allPrevSegments.filter(isReachable);\n+\n+ \/**\n+ * An array of the next segments.\n+ * This array includes unreachable segments.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ this.allNextSegments = [];\n+\n+ \/**\n+ * An array of the previous segments.\n+ * This array includes unreachable segments.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ this.allPrevSegments = allPrevSegments;\n+\n+ \/**\n+ * A flag which shows this is reachable.\n+ * @type {boolean}\n+ *\/\n+ this.reachable = reachable;\n+\n+ \/\/ Internal data.\n+ Object.defineProperty(this, 'internal', {\n+ value: {\n+ used: false,\n+ loopedPrevSegments: [],\n+ },\n+ });\n+ }\n+\n+ \/**\n+ * Checks a given previous segment is coming from the end of a loop.\n+ * @param {CodePathSegment} segment A previous segment to check.\n+ * @returns {boolean} `true` if the segment is coming from the end of a loop.\n+ *\/\n+ isLoopedPrevSegment(segment) {\n+ return this.internal.loopedPrevSegments.includes(segment);\n+ }\n+\n+ \/**\n+ * Creates the root segment.\n+ * @param {string} id An identifier.\n+ * @returns {CodePathSegment} The created segment.\n+ *\/\n+ static newRoot(id) {\n+ return new CodePathSegment(id, [], true);\n+ }\n+\n+ \/**\n+ * Creates a segment that follows given segments.\n+ * @param {string} id An identifier.\n+ * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n+ * @returns {CodePathSegment} The created segment.\n+ *\/\n+ static newNext(id, allPrevSegments) {\n+ return new CodePathSegment(\n+ id,\n+ CodePathSegment.flattenUnusedSegments(allPrevSegments),\n+ allPrevSegments.some(isReachable),\n+ );\n+ }\n+\n+ \/**\n+ * Creates an unreachable segment that follows given segments.\n+ * @param {string} id An identifier.\n+ * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n+ * @returns {CodePathSegment} The created segment.\n+ *\/\n+ static newUnreachable(id, allPrevSegments) {\n+ const segment = new CodePathSegment(\n+ id,\n+ CodePathSegment.flattenUnusedSegments(allPrevSegments),\n+ false,\n+ );\n+\n+ \/*\n+ * In `if (a) return a; foo();` case, the unreachable segment preceded by\n+ * the return statement is not used but must not be remove.\n+ *\/\n+ CodePathSegment.markUsed(segment);\n+\n+ return segment;\n+ }\n+\n+ \/**\n+ * Creates a segment that follows given segments.\n+ * This factory method does not connect with `allPrevSegments`.\n+ * But this inherits `reachable` flag.\n+ * @param {string} id An identifier.\n+ * @param {CodePathSegment[]} allPrevSegments An array of the previous segments.\n+ * @returns {CodePathSegment} The created segment.\n+ *\/\n+ static newDisconnected(id, allPrevSegments) {\n+ return new CodePathSegment(id, [], allPrevSegments.some(isReachable));\n+ }\n+\n+ \/**\n+ * Makes a given segment being used.\n+ *\n+ * And this function registers the segment into the previous segments as a next.\n+ * @param {CodePathSegment} segment A segment to mark.\n+ * @returns {void}\n+ *\/\n+ static markUsed(segment) {\n+ if (segment.internal.used) {\n+ return;\n+ }\n+ segment.internal.used = true;\n+\n+ let i;\n+\n+ if (segment.reachable) {\n+ for (i = 0; i < segment.allPrevSegments.length; ++i) {\n+ const prevSegment = segment.allPrevSegments[i];\n+\n+ prevSegment.allNextSegments.push(segment);\n+ prevSegment.nextSegments.push(segment);\n+ }\n+ } else {\n+ for (i = 0; i < segment.allPrevSegments.length; ++i) {\n+ segment.allPrevSegments[i].allNextSegments.push(segment);\n+ }\n+ }\n+ }\n+\n+ \/**\n+ * Marks a previous segment as looped.\n+ * @param {CodePathSegment} segment A segment.\n+ * @param {CodePathSegment} prevSegment A previous segment to mark.\n+ * @returns {void}\n+ *\/\n+ static markPrevSegmentAsLooped(segment, prevSegment) {\n+ segment.internal.loopedPrevSegments.push(prevSegment);\n+ }\n+\n+ \/**\n+ * Replaces unused segments with the previous segments of each unused segment.\n+ * @param {CodePathSegment[]} segments An array of segments to replace.\n+ * @returns {CodePathSegment[]} The replaced array.\n+ *\/\n+ static flattenUnusedSegments(segments) {\n+ const done = Object.create(null);\n+ const retv = [];\n+\n+ for (let i = 0; i < segments.length; ++i) {\n+ const segment = segments[i];\n+\n+ \/\/ Ignores duplicated.\n+ if (done[segment.id]) {\n+ continue;\n+ }\n+\n+ \/\/ Use previous segments if unused.\n+ if (!segment.internal.used) {\n+ for (let j = 0; j < segment.allPrevSegments.length; ++j) {\n+ const prevSegment = segment.allPrevSegments[j];\n+\n+ if (!done[prevSegment.id]) {\n+ done[prevSegment.id] = true;\n+ retv.push(prevSegment);\n+ }\n+ }\n+ } else {\n+ done[segment.id] = true;\n+ retv.push(segment);\n+ }\n+ }\n+\n+ return retv;\n+ }\n+}\n+\n+module.exports = CodePathSegment;\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-state.js b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-state.js\nnew file mode 100644\nindex 0000000000..9a107fecd7\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path-state.js\n@@ -0,0 +1,1441 @@\n+'use strict';\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Requirements\n+\/\/------------------------------------------------------------------------------\n+\n+\/\/ eslint-disable-next-line\n+const CodePathSegment = require('.\/code-path-segment');\n+\/\/ eslint-disable-next-line\n+const ForkContext = require('.\/fork-context');\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Helpers\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * Adds given segments into the `dest` array.\n+ * If the `others` array does not includes the given segments, adds to the `all`\n+ * array as well.\n+ *\n+ * This adds only reachable and used segments.\n+ * @param {CodePathSegment[]} dest A destination array (`returnedSegments` or `thrownSegments`).\n+ * @param {CodePathSegment[]} others Another destination array (`returnedSegments` or `thrownSegments`).\n+ * @param {CodePathSegment[]} all The unified destination array (`finalSegments`).\n+ * @param {CodePathSegment[]} segments Segments to add.\n+ * @returns {void}\n+ *\/\n+function addToReturnedOrThrown(dest, others, all, segments) {\n+ for (let i = 0; i < segments.length; ++i) {\n+ const segment = segments[i];\n+\n+ dest.push(segment);\n+ if (!others.includes(segment)) {\n+ all.push(segment);\n+ }\n+ }\n+}\n+\n+\/**\n+ * Gets a loop-context for a `continue` statement.\n+ * @param {CodePathState} state A state to get.\n+ * @param {string} label The label of a `continue` statement.\n+ * @returns {LoopContext} A loop-context for a `continue` statement.\n+ *\/\n+function getContinueContext(state, label) {\n+ if (!label) {\n+ return state.loopContext;\n+ }\n+\n+ let context = state.loopContext;\n+\n+ while (context) {\n+ if (context.label === label) {\n+ return context;\n+ }\n+ context = context.upper;\n+ }\n+\n+ \/* c8 ignore next *\/\n+ return null;\n+}\n+\n+\/**\n+ * Gets a context for a `break` statement.\n+ * @param {CodePathState} state A state to get.\n+ * @param {string} label The label of a `break` statement.\n+ * @returns {LoopContext|SwitchContext} A context for a `break` statement.\n+ *\/\n+function getBreakContext(state, label) {\n+ let context = state.breakContext;\n+\n+ while (context) {\n+ if (label ? context.label === label : context.breakable) {\n+ return context;\n+ }\n+ context = context.upper;\n+ }\n+\n+ \/* c8 ignore next *\/\n+ return null;\n+}\n+\n+\/**\n+ * Gets a context for a `return` statement.\n+ * @param {CodePathState} state A state to get.\n+ * @returns {TryContext|CodePathState} A context for a `return` statement.\n+ *\/\n+function getReturnContext(state) {\n+ let context = state.tryContext;\n+\n+ while (context) {\n+ if (context.hasFinalizer && context.position !== 'finally') {\n+ return context;\n+ }\n+ context = context.upper;\n+ }\n+\n+ return state;\n+}\n+\n+\/**\n+ * Gets a context for a `throw` statement.\n+ * @param {CodePathState} state A state to get.\n+ * @returns {TryContext|CodePathState} A context for a `throw` statement.\n+ *\/\n+function getThrowContext(state) {\n+ let context = state.tryContext;\n+\n+ while (context) {\n+ if (\n+ context.position === 'try' ||\n+ (context.hasFinalizer && context.position === 'catch')\n+ ) {\n+ return context;\n+ }\n+ context = context.upper;\n+ }\n+\n+ return state;\n+}\n+\n+\/**\n+ * Removes a given element from a given array.\n+ * @param {any[]} xs An array to remove the specific element.\n+ * @param {any} x An element to be removed.\n+ * @returns {void}\n+ *\/\n+function remove(xs, x) {\n+ xs.splice(xs.indexOf(x), 1);\n+}\n+\n+\/**\n+ * Disconnect given segments.\n+ *\n+ * This is used in a process for switch statements.\n+ * If there is the \"default\" chunk before other cases, the order is different\n+ * between node's and running's.\n+ * @param {CodePathSegment[]} prevSegments Forward segments to disconnect.\n+ * @param {CodePathSegment[]} nextSegments Backward segments to disconnect.\n+ * @returns {void}\n+ *\/\n+function removeConnection(prevSegments, nextSegments) {\n+ for (let i = 0; i < prevSegments.length; ++i) {\n+ const prevSegment = prevSegments[i];\n+ const nextSegment = nextSegments[i];\n+\n+ remove(prevSegment.nextSegments, nextSegment);\n+ remove(prevSegment.allNextSegments, nextSegment);\n+ remove(nextSegment.prevSegments, prevSegment);\n+ remove(nextSegment.allPrevSegments, prevSegment);\n+ }\n+}\n+\n+\/**\n+ * Creates looping path.\n+ * @param {CodePathState} state The instance.\n+ * @param {CodePathSegment[]} unflattenedFromSegments Segments which are source.\n+ * @param {CodePathSegment[]} unflattenedToSegments Segments which are destination.\n+ * @returns {void}\n+ *\/\n+function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {\n+ const fromSegments = CodePathSegment.flattenUnusedSegments(\n+ unflattenedFromSegments,\n+ );\n+ const toSegments = CodePathSegment.flattenUnusedSegments(\n+ unflattenedToSegments,\n+ );\n+\n+ const end = Math.min(fromSegments.length, toSegments.length);\n+\n+ for (let i = 0; i < end; ++i) {\n+ const fromSegment = fromSegments[i];\n+ const toSegment = toSegments[i];\n+\n+ if (toSegment.reachable) {\n+ fromSegment.nextSegments.push(toSegment);\n+ }\n+ if (fromSegment.reachable) {\n+ toSegment.prevSegments.push(fromSegment);\n+ }\n+ fromSegment.allNextSegments.push(toSegment);\n+ toSegment.allPrevSegments.push(fromSegment);\n+\n+ if (toSegment.allPrevSegments.length >= 2) {\n+ CodePathSegment.markPrevSegmentAsLooped(toSegment, fromSegment);\n+ }\n+\n+ state.notifyLooped(fromSegment, toSegment);\n+ }\n+}\n+\n+\/**\n+ * Finalizes segments of `test` chunk of a ForStatement.\n+ *\n+ * - Adds `false` paths to paths which are leaving from the loop.\n+ * - Sets `true` paths to paths which go to the body.\n+ * @param {LoopContext} context A loop context to modify.\n+ * @param {ChoiceContext} choiceContext A choice context of this loop.\n+ * @param {CodePathSegment[]} head The current head paths.\n+ * @returns {void}\n+ *\/\n+function finalizeTestSegmentsOfFor(context, choiceContext, head) {\n+ if (!choiceContext.processed) {\n+ choiceContext.trueForkContext.add(head);\n+ choiceContext.falseForkContext.add(head);\n+ choiceContext.qqForkContext.add(head);\n+ }\n+\n+ if (context.test !== true) {\n+ context.brokenForkContext.addAll(choiceContext.falseForkContext);\n+ }\n+ context.endOfTestSegments = choiceContext.trueForkContext.makeNext(0, -1);\n+}\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Public Interface\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * A class which manages state to analyze code paths.\n+ *\/\n+class CodePathState {\n+ \/**\n+ * @param {IdGenerator} idGenerator An id generator to generate id for code\n+ * path segments.\n+ * @param {Function} onLooped A callback function to notify looping.\n+ *\/\n+ constructor(idGenerator, onLooped) {\n+ this.idGenerator = idGenerator;\n+ this.notifyLooped = onLooped;\n+ this.forkContext = ForkContext.newRoot(idGenerator);\n+ this.choiceContext = null;\n+ this.switchContext = null;\n+ this.tryContext = null;\n+ this.loopContext = null;\n+ this.breakContext = null;\n+ this.chainContext = null;\n+\n+ this.currentSegments = [];\n+ this.initialSegment = this.forkContext.head[0];\n+\n+ \/\/ returnedSegments and thrownSegments push elements into finalSegments also.\n+ const final = (this.finalSegments = []);\n+ const returned = (this.returnedForkContext = []);\n+ const thrown = (this.thrownForkContext = []);\n+\n+ returned.add = addToReturnedOrThrown.bind(null, returned, thrown, final);\n+ thrown.add = addToReturnedOrThrown.bind(null, thrown, returned, final);\n+ }\n+\n+ \/**\n+ * The head segments.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ get headSegments() {\n+ return this.forkContext.head;\n+ }\n+\n+ \/**\n+ * The parent forking context.\n+ * This is used for the root of new forks.\n+ * @type {ForkContext}\n+ *\/\n+ get parentForkContext() {\n+ const current = this.forkContext;\n+\n+ return current && current.upper;\n+ }\n+\n+ \/**\n+ * Creates and stacks new forking context.\n+ * @param {boolean} forkLeavingPath A flag which shows being in a\n+ * \"finally\" block.\n+ * @returns {ForkContext} The created context.\n+ *\/\n+ pushForkContext(forkLeavingPath) {\n+ this.forkContext = ForkContext.newEmpty(this.forkContext, forkLeavingPath);\n+\n+ return this.forkContext;\n+ }\n+\n+ \/**\n+ * Pops and merges the last forking context.\n+ * @returns {ForkContext} The last context.\n+ *\/\n+ popForkContext() {\n+ const lastContext = this.forkContext;\n+\n+ this.forkContext = lastContext.upper;\n+ this.forkContext.replaceHead(lastContext.makeNext(0, -1));\n+\n+ return lastContext;\n+ }\n+\n+ \/**\n+ * Creates a new path.\n+ * @returns {void}\n+ *\/\n+ forkPath() {\n+ this.forkContext.add(this.parentForkContext.makeNext(-1, -1));\n+ }\n+\n+ \/**\n+ * Creates a bypass path.\n+ * This is used for such as IfStatement which does not have \"else\" chunk.\n+ * @returns {void}\n+ *\/\n+ forkBypassPath() {\n+ this.forkContext.add(this.parentForkContext.head);\n+ }\n+\n+ \/\/--------------------------------------------------------------------------\n+ \/\/ ConditionalExpression, LogicalExpression, IfStatement\n+ \/\/--------------------------------------------------------------------------\n+\n+ \/**\n+ * Creates a context for ConditionalExpression, LogicalExpression, AssignmentExpression (logical assignments only),\n+ * IfStatement, WhileStatement, DoWhileStatement, or ForStatement.\n+ *\n+ * LogicalExpressions have cases that it goes different paths between the\n+ * `true` case and the `false` case.\n+ *\n+ * For Example:\n+ *\n+ * if (a || b) {\n+ * foo();\n+ * } else {\n+ * bar();\n+ * }\n+ *\n+ * In this case, `b` is evaluated always in the code path of the `else`\n+ * block, but it's not so in the code path of the `if` block.\n+ * So there are 3 paths.\n+ *\n+ * a -> foo();\n+ * a -> b -> foo();\n+ * a -> b -> bar();\n+ * @param {string} kind A kind string.\n+ * If the new context is LogicalExpression's or AssignmentExpression's, this is `\"&&\"` or `\"||\"` or `\"??\"`.\n+ * If it's IfStatement's or ConditionalExpression's, this is `\"test\"`.\n+ * Otherwise, this is `\"loop\"`.\n+ * @param {boolean} isForkingAsResult A flag that shows that goes different\n+ * paths between `true` and `false`.\n+ * @returns {void}\n+ *\/\n+ pushChoiceContext(kind, isForkingAsResult) {\n+ this.choiceContext = {\n+ upper: this.choiceContext,\n+ kind,\n+ isForkingAsResult,\n+ trueForkContext: ForkContext.newEmpty(this.forkContext),\n+ falseForkContext: ForkContext.newEmpty(this.forkContext),\n+ qqForkContext: ForkContext.newEmpty(this.forkContext),\n+ processed: false,\n+ };\n+ }\n+\n+ \/**\n+ * Pops the last choice context and finalizes it.\n+ * @throws {Error} (Unreachable.)\n+ * @returns {ChoiceContext} The popped context.\n+ *\/\n+ popChoiceContext() {\n+ const context = this.choiceContext;\n+\n+ this.choiceContext = context.upper;\n+\n+ const forkContext = this.forkContext;\n+ const headSegments = forkContext.head;\n+\n+ switch (context.kind) {\n+ case '&&':\n+ case '||':\n+ case '??':\n+ \/*\n+ * If any result were not transferred from child contexts,\n+ * this sets the head segments to both cases.\n+ * The head segments are the path of the right-hand operand.\n+ *\/\n+ if (!context.processed) {\n+ context.trueForkContext.add(headSegments);\n+ context.falseForkContext.add(headSegments);\n+ context.qqForkContext.add(headSegments);\n+ }\n+\n+ \/*\n+ * Transfers results to upper context if this context is in\n+ * test chunk.\n+ *\/\n+ if (context.isForkingAsResult) {\n+ const parentContext = this.choiceContext;\n+\n+ parentContext.trueForkContext.addAll(context.trueForkContext);\n+ parentContext.falseForkContext.addAll(context.falseForkContext);\n+ parentContext.qqForkContext.addAll(context.qqForkContext);\n+ parentContext.processed = true;\n+\n+ return context;\n+ }\n+\n+ break;\n+\n+ case 'test':\n+ if (!context.processed) {\n+ \/*\n+ * The head segments are the path of the `if` block here.\n+ * Updates the `true` path with the end of the `if` block.\n+ *\/\n+ context.trueForkContext.clear();\n+ context.trueForkContext.add(headSegments);\n+ } else {\n+ \/*\n+ * The head segments are the path of the `else` block here.\n+ * Updates the `false` path with the end of the `else`\n+ * block.\n+ *\/\n+ context.falseForkContext.clear();\n+ context.falseForkContext.add(headSegments);\n+ }\n+\n+ break;\n+\n+ case 'loop':\n+ \/*\n+ * Loops are addressed in popLoopContext().\n+ * This is called from popLoopContext().\n+ *\/\n+ return context;\n+\n+ \/* c8 ignore next *\/\n+ default:\n+ throw new Error('unreachable');\n+ }\n+\n+ \/\/ Merges all paths.\n+ const prevForkContext = context.trueForkContext;\n+\n+ prevForkContext.addAll(context.falseForkContext);\n+ forkContext.replaceHead(prevForkContext.makeNext(0, -1));\n+\n+ return context;\n+ }\n+\n+ \/**\n+ * Makes a code path segment of the right-hand operand of a logical\n+ * expression.\n+ * @throws {Error} (Unreachable.)\n+ * @returns {void}\n+ *\/\n+ makeLogicalRight() {\n+ const context = this.choiceContext;\n+ const forkContext = this.forkContext;\n+\n+ if (context.processed) {\n+ \/*\n+ * This got segments already from the child choice context.\n+ * Creates the next path from own true\/false fork context.\n+ *\/\n+ let prevForkContext;\n+\n+ switch (context.kind) {\n+ case '&&': \/\/ if true then go to the right-hand side.\n+ prevForkContext = context.trueForkContext;\n+ break;\n+ case '||': \/\/ if false then go to the right-hand side.\n+ prevForkContext = context.falseForkContext;\n+ break;\n+ case '??': \/\/ Both true\/false can short-circuit, so needs the third path to go to the right-hand side. That's qqForkContext.\n+ prevForkContext = context.qqForkContext;\n+ break;\n+ default:\n+ throw new Error('unreachable');\n+ }\n+\n+ forkContext.replaceHead(prevForkContext.makeNext(0, -1));\n+ prevForkContext.clear();\n+ context.processed = false;\n+ } else {\n+ \/*\n+ * This did not get segments from the child choice context.\n+ * So addresses the head segments.\n+ * The head segments are the path of the left-hand operand.\n+ *\/\n+ switch (context.kind) {\n+ case '&&': \/\/ the false path can short-circuit.\n+ context.falseForkContext.add(forkContext.head);\n+ break;\n+ case '||': \/\/ the true path can short-circuit.\n+ context.trueForkContext.add(forkContext.head);\n+ break;\n+ case '??': \/\/ both can short-circuit.\n+ context.trueForkContext.add(forkContext.head);\n+ context.falseForkContext.add(forkContext.head);\n+ break;\n+ default:\n+ throw new Error('unreachable');\n+ }\n+\n+ forkContext.replaceHead(forkContext.makeNext(-1, -1));\n+ }\n+ }\n+\n+ \/**\n+ * Makes a code path segment of the `if` block.\n+ * @returns {void}\n+ *\/\n+ makeIfConsequent() {\n+ const context = this.choiceContext;\n+ const forkContext = this.forkContext;\n+\n+ \/*\n+ * If any result were not transferred from child contexts,\n+ * this sets the head segments to both cases.\n+ * The head segments are the path of the test expression.\n+ *\/\n+ if (!context.processed) {\n+ context.trueForkContext.add(forkContext.head);\n+ context.falseForkContext.add(forkContext.head);\n+ context.qqForkContext.add(forkContext.head);\n+ }\n+\n+ context.processed = false;\n+\n+ \/\/ Creates new path from the `true` case.\n+ forkContext.replaceHead(context.trueForkContext.makeNext(0, -1));\n+ }\n+\n+ \/**\n+ * Makes a code path segment of the `else` block.\n+ * @returns {void}\n+ *\/\n+ makeIfAlternate() {\n+ const context = this.choiceContext;\n+ const forkContext = this.forkContext;\n+\n+ \/*\n+ * The head segments are the path of the `if` block.\n+ * Updates the `true` path with the end of the `if` block.\n+ *\/\n+ context.trueForkContext.clear();\n+ context.trueForkContext.add(forkContext.head);\n+ context.processed = true;\n+\n+ \/\/ Creates new path from the `false` case.\n+ forkContext.replaceHead(context.falseForkContext.makeNext(0, -1));\n+ }\n+\n+ \/\/--------------------------------------------------------------------------\n+ \/\/ ChainExpression\n+ \/\/--------------------------------------------------------------------------\n+\n+ \/**\n+ * Push a new `ChainExpression` context to the stack.\n+ * This method is called on entering to each `ChainExpression` node.\n+ * This context is used to count forking in the optional chain then merge them on the exiting from the `ChainExpression` node.\n+ * @returns {void}\n+ *\/\n+ pushChainContext() {\n+ this.chainContext = {\n+ upper: this.chainContext,\n+ countChoiceContexts: 0,\n+ };\n+ }\n+\n+ \/**\n+ * Pop a `ChainExpression` context from the stack.\n+ * This method is called on exiting from each `ChainExpression` node.\n+ * This merges all forks of the last optional chaining.\n+ * @returns {void}\n+ *\/\n+ popChainContext() {\n+ const context = this.chainContext;\n+\n+ this.chainContext = context.upper;\n+\n+ \/\/ pop all choice contexts of this.\n+ for (let i = context.countChoiceContexts; i > 0; --i) {\n+ this.popChoiceContext();\n+ }\n+ }\n+\n+ \/**\n+ * Create a choice context for optional access.\n+ * This method is called on entering to each `(Call|Member)Expression[optional=true]` node.\n+ * This creates a choice context as similar to `LogicalExpression[operator=\"??\"]` node.\n+ * @returns {void}\n+ *\/\n+ makeOptionalNode() {\n+ if (this.chainContext) {\n+ this.chainContext.countChoiceContexts += 1;\n+ this.pushChoiceContext('??', false);\n+ }\n+ }\n+\n+ \/**\n+ * Create a fork.\n+ * This method is called on entering to the `arguments|property` property of each `(Call|Member)Expression` node.\n+ * @returns {void}\n+ *\/\n+ makeOptionalRight() {\n+ if (this.chainContext) {\n+ this.makeLogicalRight();\n+ }\n+ }\n+\n+ \/\/--------------------------------------------------------------------------\n+ \/\/ SwitchStatement\n+ \/\/--------------------------------------------------------------------------\n+\n+ \/**\n+ * Creates a context object of SwitchStatement and stacks it.\n+ * @param {boolean} hasCase `true` if the switch statement has one or more\n+ * case parts.\n+ * @param {string|null} label The label text.\n+ * @returns {void}\n+ *\/\n+ pushSwitchContext(hasCase, label) {\n+ this.switchContext = {\n+ upper: this.switchContext,\n+ hasCase,\n+ defaultSegments: null,\n+ defaultBodySegments: null,\n+ foundDefault: false,\n+ lastIsDefault: false,\n+ countForks: 0,\n+ };\n+\n+ this.pushBreakContext(true, label);\n+ }\n+\n+ \/**\n+ * Pops the last context of SwitchStatement and finalizes it.\n+ *\n+ * - Disposes all forking stack for `case` and `default`.\n+ * - Creates the next code path segment from `context.brokenForkContext`.\n+ * - If the last `SwitchCase` node is not a `default` part, creates a path\n+ * to the `default` body.\n+ * @returns {void}\n+ *\/\n+ popSwitchContext() {\n+ const context = this.switchContext;\n+\n+ this.switchContext = context.upper;\n+\n+ const forkContext = this.forkContext;\n+ const brokenForkContext = this.popBreakContext().brokenForkContext;\n+\n+ if (context.countForks === 0) {\n+ \/*\n+ * When there is only one `default` chunk and there is one or more\n+ * `break` statements, even if forks are nothing, it needs to merge\n+ * those.\n+ *\/\n+ if (!brokenForkContext.empty) {\n+ brokenForkContext.add(forkContext.makeNext(-1, -1));\n+ forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n+ }\n+\n+ return;\n+ }\n+\n+ const lastSegments = forkContext.head;\n+\n+ this.forkBypassPath();\n+ const lastCaseSegments = forkContext.head;\n+\n+ \/*\n+ * `brokenForkContext` is used to make the next segment.\n+ * It must add the last segment into `brokenForkContext`.\n+ *\/\n+ brokenForkContext.add(lastSegments);\n+\n+ \/*\n+ * A path which is failed in all case test should be connected to path\n+ * of `default` chunk.\n+ *\/\n+ if (!context.lastIsDefault) {\n+ if (context.defaultBodySegments) {\n+ \/*\n+ * Remove a link from `default` label to its chunk.\n+ * It's false route.\n+ *\/\n+ removeConnection(context.defaultSegments, context.defaultBodySegments);\n+ makeLooped(this, lastCaseSegments, context.defaultBodySegments);\n+ } else {\n+ \/*\n+ * It handles the last case body as broken if `default` chunk\n+ * does not exist.\n+ *\/\n+ brokenForkContext.add(lastCaseSegments);\n+ }\n+ }\n+\n+ \/\/ Pops the segment context stack until the entry segment.\n+ for (let i = 0; i < context.countForks; ++i) {\n+ this.forkContext = this.forkContext.upper;\n+ }\n+\n+ \/*\n+ * Creates a path from all brokenForkContext paths.\n+ * This is a path after switch statement.\n+ *\/\n+ this.forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n+ }\n+\n+ \/**\n+ * Makes a code path segment for a `SwitchCase` node.\n+ * @param {boolean} isEmpty `true` if the body is empty.\n+ * @param {boolean} isDefault `true` if the body is the default case.\n+ * @returns {void}\n+ *\/\n+ makeSwitchCaseBody(isEmpty, isDefault) {\n+ const context = this.switchContext;\n+\n+ if (!context.hasCase) {\n+ return;\n+ }\n+\n+ \/*\n+ * Merge forks.\n+ * The parent fork context has two segments.\n+ * Those are from the current case and the body of the previous case.\n+ *\/\n+ const parentForkContext = this.forkContext;\n+ const forkContext = this.pushForkContext();\n+\n+ forkContext.add(parentForkContext.makeNext(0, -1));\n+\n+ \/*\n+ * Save `default` chunk info.\n+ * If the `default` label is not at the last, we must make a path from\n+ * the last `case` to the `default` chunk.\n+ *\/\n+ if (isDefault) {\n+ context.defaultSegments = parentForkContext.head;\n+ if (isEmpty) {\n+ context.foundDefault = true;\n+ } else {\n+ context.defaultBodySegments = forkContext.head;\n+ }\n+ } else {\n+ if (!isEmpty && context.foundDefault) {\n+ context.foundDefault = false;\n+ context.defaultBodySegments = forkContext.head;\n+ }\n+ }\n+\n+ context.lastIsDefault = isDefault;\n+ context.countForks += 1;\n+ }\n+\n+ \/\/--------------------------------------------------------------------------\n+ \/\/ TryStatement\n+ \/\/--------------------------------------------------------------------------\n+\n+ \/**\n+ * Creates a context object of TryStatement and stacks it.\n+ * @param {boolean} hasFinalizer `true` if the try statement has a\n+ * `finally` block.\n+ * @returns {void}\n+ *\/\n+ pushTryContext(hasFinalizer) {\n+ this.tryContext = {\n+ upper: this.tryContext,\n+ position: 'try',\n+ hasFinalizer,\n+\n+ returnedForkContext: hasFinalizer\n+ ? ForkContext.newEmpty(this.forkContext)\n+ : null,\n+\n+ thrownForkContext: ForkContext.newEmpty(this.forkContext),\n+ lastOfTryIsReachable: false,\n+ lastOfCatchIsReachable: false,\n+ };\n+ }\n+\n+ \/**\n+ * Pops the last context of TryStatement and finalizes it.\n+ * @returns {void}\n+ *\/\n+ popTryContext() {\n+ const context = this.tryContext;\n+\n+ this.tryContext = context.upper;\n+\n+ if (context.position === 'catch') {\n+ \/\/ Merges two paths from the `try` block and `catch` block merely.\n+ this.popForkContext();\n+ return;\n+ }\n+\n+ \/*\n+ * The following process is executed only when there is the `finally`\n+ * block.\n+ *\/\n+\n+ const returned = context.returnedForkContext;\n+ const thrown = context.thrownForkContext;\n+\n+ if (returned.empty && thrown.empty) {\n+ return;\n+ }\n+\n+ \/\/ Separate head to normal paths and leaving paths.\n+ const headSegments = this.forkContext.head;\n+\n+ this.forkContext = this.forkContext.upper;\n+ const normalSegments = headSegments.slice(0, (headSegments.length \/ 2) | 0);\n+ const leavingSegments = headSegments.slice((headSegments.length \/ 2) | 0);\n+\n+ \/\/ Forwards the leaving path to upper contexts.\n+ if (!returned.empty) {\n+ getReturnContext(this).returnedForkContext.add(leavingSegments);\n+ }\n+ if (!thrown.empty) {\n+ getThrowContext(this).thrownForkContext.add(leavingSegments);\n+ }\n+\n+ \/\/ Sets the normal path as the next.\n+ this.forkContext.replaceHead(normalSegments);\n+\n+ \/*\n+ * If both paths of the `try` block and the `catch` block are\n+ * unreachable, the next path becomes unreachable as well.\n+ *\/\n+ if (!context.lastOfTryIsReachable && !context.lastOfCatchIsReachable) {\n+ this.forkContext.makeUnreachable();\n+ }\n+ }\n+\n+ \/**\n+ * Makes a code path segment for a `catch` block.\n+ * @returns {void}\n+ *\/\n+ makeCatchBlock() {\n+ const context = this.tryContext;\n+ const forkContext = this.forkContext;\n+ const thrown = context.thrownForkContext;\n+\n+ \/\/ Update state.\n+ context.position = 'catch';\n+ context.thrownForkContext = ForkContext.newEmpty(forkContext);\n+ context.lastOfTryIsReachable = forkContext.reachable;\n+\n+ \/\/ Merge thrown paths.\n+ thrown.add(forkContext.head);\n+ const thrownSegments = thrown.makeNext(0, -1);\n+\n+ \/\/ Fork to a bypass and the merged thrown path.\n+ this.pushForkContext();\n+ this.forkBypassPath();\n+ this.forkContext.add(thrownSegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for a `finally` block.\n+ *\n+ * In the `finally` block, parallel paths are created. The parallel paths\n+ * are used as leaving-paths. The leaving-paths are paths from `return`\n+ * statements and `throw` statements in a `try` block or a `catch` block.\n+ * @returns {void}\n+ *\/\n+ makeFinallyBlock() {\n+ const context = this.tryContext;\n+ let forkContext = this.forkContext;\n+ const returned = context.returnedForkContext;\n+ const thrown = context.thrownForkContext;\n+ const headOfLeavingSegments = forkContext.head;\n+\n+ \/\/ Update state.\n+ if (context.position === 'catch') {\n+ \/\/ Merges two paths from the `try` block and `catch` block.\n+ this.popForkContext();\n+ forkContext = this.forkContext;\n+\n+ context.lastOfCatchIsReachable = forkContext.reachable;\n+ } else {\n+ context.lastOfTryIsReachable = forkContext.reachable;\n+ }\n+ context.position = 'finally';\n+\n+ if (returned.empty && thrown.empty) {\n+ \/\/ This path does not leave.\n+ return;\n+ }\n+\n+ \/*\n+ * Create a parallel segment from merging returned and thrown.\n+ * This segment will leave at the end of this finally block.\n+ *\/\n+ const segments = forkContext.makeNext(-1, -1);\n+\n+ for (let i = 0; i < forkContext.count; ++i) {\n+ const prevSegsOfLeavingSegment = [headOfLeavingSegments[i]];\n+\n+ for (let j = 0; j < returned.segmentsList.length; ++j) {\n+ prevSegsOfLeavingSegment.push(returned.segmentsList[j][i]);\n+ }\n+ for (let j = 0; j < thrown.segmentsList.length; ++j) {\n+ prevSegsOfLeavingSegment.push(thrown.segmentsList[j][i]);\n+ }\n+\n+ segments.push(\n+ CodePathSegment.newNext(\n+ this.idGenerator.next(),\n+ prevSegsOfLeavingSegment,\n+ ),\n+ );\n+ }\n+\n+ this.pushForkContext(true);\n+ this.forkContext.add(segments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment from the first throwable node to the `catch`\n+ * block or the `finally` block.\n+ * @returns {void}\n+ *\/\n+ makeFirstThrowablePathInTryBlock() {\n+ const forkContext = this.forkContext;\n+\n+ if (!forkContext.reachable) {\n+ return;\n+ }\n+\n+ const context = getThrowContext(this);\n+\n+ if (\n+ context === this ||\n+ context.position !== 'try' ||\n+ !context.thrownForkContext.empty\n+ ) {\n+ return;\n+ }\n+\n+ context.thrownForkContext.add(forkContext.head);\n+ forkContext.replaceHead(forkContext.makeNext(-1, -1));\n+ }\n+\n+ \/\/--------------------------------------------------------------------------\n+ \/\/ Loop Statements\n+ \/\/--------------------------------------------------------------------------\n+\n+ \/**\n+ * Creates a context object of a loop statement and stacks it.\n+ * @param {string} type The type of the node which was triggered. One of\n+ * `WhileStatement`, `DoWhileStatement`, `ForStatement`, `ForInStatement`,\n+ * and `ForStatement`.\n+ * @param {string|null} label A label of the node which was triggered.\n+ * @throws {Error} (Unreachable - unknown type.)\n+ * @returns {void}\n+ *\/\n+ pushLoopContext(type, label) {\n+ const forkContext = this.forkContext;\n+ const breakContext = this.pushBreakContext(true, label);\n+\n+ switch (type) {\n+ case 'WhileStatement':\n+ this.pushChoiceContext('loop', false);\n+ this.loopContext = {\n+ upper: this.loopContext,\n+ type,\n+ label,\n+ test: void 0,\n+ continueDestSegments: null,\n+ brokenForkContext: breakContext.brokenForkContext,\n+ };\n+ break;\n+\n+ case 'DoWhileStatement':\n+ this.pushChoiceContext('loop', false);\n+ this.loopContext = {\n+ upper: this.loopContext,\n+ type,\n+ label,\n+ test: void 0,\n+ entrySegments: null,\n+ continueForkContext: ForkContext.newEmpty(forkContext),\n+ brokenForkContext: breakContext.brokenForkContext,\n+ };\n+ break;\n+\n+ case 'ForStatement':\n+ this.pushChoiceContext('loop', false);\n+ this.loopContext = {\n+ upper: this.loopContext,\n+ type,\n+ label,\n+ test: void 0,\n+ endOfInitSegments: null,\n+ testSegments: null,\n+ endOfTestSegments: null,\n+ updateSegments: null,\n+ endOfUpdateSegments: null,\n+ continueDestSegments: null,\n+ brokenForkContext: breakContext.brokenForkContext,\n+ };\n+ break;\n+\n+ case 'ForInStatement':\n+ case 'ForOfStatement':\n+ this.loopContext = {\n+ upper: this.loopContext,\n+ type,\n+ label,\n+ prevSegments: null,\n+ leftSegments: null,\n+ endOfLeftSegments: null,\n+ continueDestSegments: null,\n+ brokenForkContext: breakContext.brokenForkContext,\n+ };\n+ break;\n+\n+ \/* c8 ignore next *\/\n+ default:\n+ throw new Error(`unknown type: \"${type}\"`);\n+ }\n+ }\n+\n+ \/**\n+ * Pops the last context of a loop statement and finalizes it.\n+ * @throws {Error} (Unreachable - unknown type.)\n+ * @returns {void}\n+ *\/\n+ popLoopContext() {\n+ const context = this.loopContext;\n+\n+ this.loopContext = context.upper;\n+\n+ const forkContext = this.forkContext;\n+ const brokenForkContext = this.popBreakContext().brokenForkContext;\n+\n+ \/\/ Creates a looped path.\n+ switch (context.type) {\n+ case 'WhileStatement':\n+ case 'ForStatement':\n+ this.popChoiceContext();\n+ makeLooped(this, forkContext.head, context.continueDestSegments);\n+ break;\n+\n+ case 'DoWhileStatement': {\n+ const choiceContext = this.popChoiceContext();\n+\n+ if (!choiceContext.processed) {\n+ choiceContext.trueForkContext.add(forkContext.head);\n+ choiceContext.falseForkContext.add(forkContext.head);\n+ }\n+ if (context.test !== true) {\n+ brokenForkContext.addAll(choiceContext.falseForkContext);\n+ }\n+\n+ \/\/ `true` paths go to looping.\n+ const segmentsList = choiceContext.trueForkContext.segmentsList;\n+\n+ for (let i = 0; i < segmentsList.length; ++i) {\n+ makeLooped(this, segmentsList[i], context.entrySegments);\n+ }\n+ break;\n+ }\n+\n+ case 'ForInStatement':\n+ case 'ForOfStatement':\n+ brokenForkContext.add(forkContext.head);\n+ makeLooped(this, forkContext.head, context.leftSegments);\n+ break;\n+\n+ \/* c8 ignore next *\/\n+ default:\n+ throw new Error('unreachable');\n+ }\n+\n+ \/\/ Go next.\n+ if (brokenForkContext.empty) {\n+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n+ } else {\n+ forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n+ }\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the test part of a WhileStatement.\n+ * @param {boolean|undefined} test The test value (only when constant).\n+ * @returns {void}\n+ *\/\n+ makeWhileTest(test) {\n+ const context = this.loopContext;\n+ const forkContext = this.forkContext;\n+ const testSegments = forkContext.makeNext(0, -1);\n+\n+ \/\/ Update state.\n+ context.test = test;\n+ context.continueDestSegments = testSegments;\n+ forkContext.replaceHead(testSegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the body part of a WhileStatement.\n+ * @returns {void}\n+ *\/\n+ makeWhileBody() {\n+ const context = this.loopContext;\n+ const choiceContext = this.choiceContext;\n+ const forkContext = this.forkContext;\n+\n+ if (!choiceContext.processed) {\n+ choiceContext.trueForkContext.add(forkContext.head);\n+ choiceContext.falseForkContext.add(forkContext.head);\n+ }\n+\n+ \/\/ Update state.\n+ if (context.test !== true) {\n+ context.brokenForkContext.addAll(choiceContext.falseForkContext);\n+ }\n+ forkContext.replaceHead(choiceContext.trueForkContext.makeNext(0, -1));\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the body part of a DoWhileStatement.\n+ * @returns {void}\n+ *\/\n+ makeDoWhileBody() {\n+ const context = this.loopContext;\n+ const forkContext = this.forkContext;\n+ const bodySegments = forkContext.makeNext(-1, -1);\n+\n+ \/\/ Update state.\n+ context.entrySegments = bodySegments;\n+ forkContext.replaceHead(bodySegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the test part of a DoWhileStatement.\n+ * @param {boolean|undefined} test The test value (only when constant).\n+ * @returns {void}\n+ *\/\n+ makeDoWhileTest(test) {\n+ const context = this.loopContext;\n+ const forkContext = this.forkContext;\n+\n+ context.test = test;\n+\n+ \/\/ Creates paths of `continue` statements.\n+ if (!context.continueForkContext.empty) {\n+ context.continueForkContext.add(forkContext.head);\n+ const testSegments = context.continueForkContext.makeNext(0, -1);\n+\n+ forkContext.replaceHead(testSegments);\n+ }\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the test part of a ForStatement.\n+ * @param {boolean|undefined} test The test value (only when constant).\n+ * @returns {void}\n+ *\/\n+ makeForTest(test) {\n+ const context = this.loopContext;\n+ const forkContext = this.forkContext;\n+ const endOfInitSegments = forkContext.head;\n+ const testSegments = forkContext.makeNext(-1, -1);\n+\n+ \/\/ Update state.\n+ context.test = test;\n+ context.endOfInitSegments = endOfInitSegments;\n+ context.continueDestSegments = context.testSegments = testSegments;\n+ forkContext.replaceHead(testSegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the update part of a ForStatement.\n+ * @returns {void}\n+ *\/\n+ makeForUpdate() {\n+ const context = this.loopContext;\n+ const choiceContext = this.choiceContext;\n+ const forkContext = this.forkContext;\n+\n+ \/\/ Make the next paths of the test.\n+ if (context.testSegments) {\n+ finalizeTestSegmentsOfFor(context, choiceContext, forkContext.head);\n+ } else {\n+ context.endOfInitSegments = forkContext.head;\n+ }\n+\n+ \/\/ Update state.\n+ const updateSegments = forkContext.makeDisconnected(-1, -1);\n+\n+ context.continueDestSegments = context.updateSegments = updateSegments;\n+ forkContext.replaceHead(updateSegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the body part of a ForStatement.\n+ * @returns {void}\n+ *\/\n+ makeForBody() {\n+ const context = this.loopContext;\n+ const choiceContext = this.choiceContext;\n+ const forkContext = this.forkContext;\n+\n+ \/\/ Update state.\n+ if (context.updateSegments) {\n+ context.endOfUpdateSegments = forkContext.head;\n+\n+ \/\/ `update` -> `test`\n+ if (context.testSegments) {\n+ makeLooped(this, context.endOfUpdateSegments, context.testSegments);\n+ }\n+ } else if (context.testSegments) {\n+ finalizeTestSegmentsOfFor(context, choiceContext, forkContext.head);\n+ } else {\n+ context.endOfInitSegments = forkContext.head;\n+ }\n+\n+ let bodySegments = context.endOfTestSegments;\n+\n+ if (!bodySegments) {\n+ \/*\n+ * If there is not the `test` part, the `body` path comes from the\n+ * `init` part and the `update` part.\n+ *\/\n+ const prevForkContext = ForkContext.newEmpty(forkContext);\n+\n+ prevForkContext.add(context.endOfInitSegments);\n+ if (context.endOfUpdateSegments) {\n+ prevForkContext.add(context.endOfUpdateSegments);\n+ }\n+\n+ bodySegments = prevForkContext.makeNext(0, -1);\n+ }\n+ context.continueDestSegments = context.continueDestSegments || bodySegments;\n+ forkContext.replaceHead(bodySegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the left part of a ForInStatement and a\n+ * ForOfStatement.\n+ * @returns {void}\n+ *\/\n+ makeForInOfLeft() {\n+ const context = this.loopContext;\n+ const forkContext = this.forkContext;\n+ const leftSegments = forkContext.makeDisconnected(-1, -1);\n+\n+ \/\/ Update state.\n+ context.prevSegments = forkContext.head;\n+ context.leftSegments = context.continueDestSegments = leftSegments;\n+ forkContext.replaceHead(leftSegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the right part of a ForInStatement and a\n+ * ForOfStatement.\n+ * @returns {void}\n+ *\/\n+ makeForInOfRight() {\n+ const context = this.loopContext;\n+ const forkContext = this.forkContext;\n+ const temp = ForkContext.newEmpty(forkContext);\n+\n+ temp.add(context.prevSegments);\n+ const rightSegments = temp.makeNext(-1, -1);\n+\n+ \/\/ Update state.\n+ context.endOfLeftSegments = forkContext.head;\n+ forkContext.replaceHead(rightSegments);\n+ }\n+\n+ \/**\n+ * Makes a code path segment for the body part of a ForInStatement and a\n+ * ForOfStatement.\n+ * @returns {void}\n+ *\/\n+ makeForInOfBody() {\n+ const context = this.loopContext;\n+ const forkContext = this.forkContext;\n+ const temp = ForkContext.newEmpty(forkContext);\n+\n+ temp.add(context.endOfLeftSegments);\n+ const bodySegments = temp.makeNext(-1, -1);\n+\n+ \/\/ Make a path: `right` -> `left`.\n+ makeLooped(this, forkContext.head, context.leftSegments);\n+\n+ \/\/ Update state.\n+ context.brokenForkContext.add(forkContext.head);\n+ forkContext.replaceHead(bodySegments);\n+ }\n+\n+ \/\/--------------------------------------------------------------------------\n+ \/\/ Control Statements\n+ \/\/--------------------------------------------------------------------------\n+\n+ \/**\n+ * Creates new context for BreakStatement.\n+ * @param {boolean} breakable The flag to indicate it can break by\n+ * an unlabeled BreakStatement.\n+ * @param {string|null} label The label of this context.\n+ * @returns {Object} The new context.\n+ *\/\n+ pushBreakContext(breakable, label) {\n+ this.breakContext = {\n+ upper: this.breakContext,\n+ breakable,\n+ label,\n+ brokenForkContext: ForkContext.newEmpty(this.forkContext),\n+ };\n+ return this.breakContext;\n+ }\n+\n+ \/**\n+ * Removes the top item of the break context stack.\n+ * @returns {Object} The removed context.\n+ *\/\n+ popBreakContext() {\n+ const context = this.breakContext;\n+ const forkContext = this.forkContext;\n+\n+ this.breakContext = context.upper;\n+\n+ \/\/ Process this context here for other than switches and loops.\n+ if (!context.breakable) {\n+ const brokenForkContext = context.brokenForkContext;\n+\n+ if (!brokenForkContext.empty) {\n+ brokenForkContext.add(forkContext.head);\n+ forkContext.replaceHead(brokenForkContext.makeNext(0, -1));\n+ }\n+ }\n+\n+ return context;\n+ }\n+\n+ \/**\n+ * Makes a path for a `break` statement.\n+ *\n+ * It registers the head segment to a context of `break`.\n+ * It makes new unreachable segment, then it set the head with the segment.\n+ * @param {string} label A label of the break statement.\n+ * @returns {void}\n+ *\/\n+ makeBreak(label) {\n+ const forkContext = this.forkContext;\n+\n+ if (!forkContext.reachable) {\n+ return;\n+ }\n+\n+ const context = getBreakContext(this, label);\n+\n+ if (context) {\n+ context.brokenForkContext.add(forkContext.head);\n+ }\n+\n+ \/* c8 ignore next *\/\n+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n+ }\n+\n+ \/**\n+ * Makes a path for a `continue` statement.\n+ *\n+ * It makes a looping path.\n+ * It makes new unreachable segment, then it set the head with the segment.\n+ * @param {string} label A label of the continue statement.\n+ * @returns {void}\n+ *\/\n+ makeContinue(label) {\n+ const forkContext = this.forkContext;\n+\n+ if (!forkContext.reachable) {\n+ return;\n+ }\n+\n+ const context = getContinueContext(this, label);\n+\n+ if (context) {\n+ if (context.continueDestSegments) {\n+ makeLooped(this, forkContext.head, context.continueDestSegments);\n+\n+ \/\/ If the context is a for-in\/of loop, this effects a break also.\n+ if (\n+ context.type === 'ForInStatement' ||\n+ context.type === 'ForOfStatement'\n+ ) {\n+ context.brokenForkContext.add(forkContext.head);\n+ }\n+ } else {\n+ context.continueForkContext.add(forkContext.head);\n+ }\n+ }\n+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n+ }\n+\n+ \/**\n+ * Makes a path for a `return` statement.\n+ *\n+ * It registers the head segment to a context of `return`.\n+ * It makes new unreachable segment, then it set the head with the segment.\n+ * @returns {void}\n+ *\/\n+ makeReturn() {\n+ const forkContext = this.forkContext;\n+\n+ if (forkContext.reachable) {\n+ getReturnContext(this).returnedForkContext.add(forkContext.head);\n+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n+ }\n+ }\n+\n+ \/**\n+ * Makes a path for a `throw` statement.\n+ *\n+ * It registers the head segment to a context of `throw`.\n+ * It makes new unreachable segment, then it set the head with the segment.\n+ * @returns {void}\n+ *\/\n+ makeThrow() {\n+ const forkContext = this.forkContext;\n+\n+ if (forkContext.reachable) {\n+ getThrowContext(this).thrownForkContext.add(forkContext.head);\n+ forkContext.replaceHead(forkContext.makeUnreachable(-1, -1));\n+ }\n+ }\n+\n+ \/**\n+ * Makes the final path.\n+ * @returns {void}\n+ *\/\n+ makeFinal() {\n+ const segments = this.currentSegments;\n+\n+ if (segments.length > 0 && segments[0].reachable) {\n+ this.returnedForkContext.add(segments);\n+ }\n+ }\n+}\n+\n+module.exports = CodePathState;\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path.js b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path.js\nnew file mode 100644\nindex 0000000000..167d9be7af\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/code-path.js\n@@ -0,0 +1,239 @@\n+'use strict';\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Requirements\n+\/\/------------------------------------------------------------------------------\n+\n+\/\/ eslint-disable-next-line\n+const CodePathState = require('.\/code-path-state');\n+\/\/ eslint-disable-next-line\n+const IdGenerator = require('.\/id-generator');\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Public Interface\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * A code path.\n+ *\/\n+class CodePath {\n+ \/**\n+ * Creates a new instance.\n+ * @param {Object} options Options for the function (see below).\n+ * @param {string} options.id An identifier.\n+ * @param {string} options.origin The type of code path origin.\n+ * @param {CodePath|null} options.upper The code path of the upper function scope.\n+ * @param {Function} options.onLooped A callback function to notify looping.\n+ *\/\n+ constructor({id, origin, upper, onLooped}) {\n+ \/**\n+ * The identifier of this code path.\n+ * Rules use it to store additional information of each rule.\n+ * @type {string}\n+ *\/\n+ this.id = id;\n+\n+ \/**\n+ * The reason that this code path was started. May be \"program\",\n+ * \"function\", \"class-field-initializer\", or \"class-static-block\".\n+ * @type {string}\n+ *\/\n+ this.origin = origin;\n+\n+ \/**\n+ * The code path of the upper function scope.\n+ * @type {CodePath|null}\n+ *\/\n+ this.upper = upper;\n+\n+ \/**\n+ * The code paths of nested function scopes.\n+ * @type {CodePath[]}\n+ *\/\n+ this.childCodePaths = [];\n+\n+ \/\/ Initializes internal state.\n+ Object.defineProperty(this, 'internal', {\n+ value: new CodePathState(new IdGenerator(`${id}_`), onLooped),\n+ });\n+\n+ \/\/ Adds this into `childCodePaths` of `upper`.\n+ if (upper) {\n+ upper.childCodePaths.push(this);\n+ }\n+ }\n+\n+ \/**\n+ * Gets the state of a given code path.\n+ * @param {CodePath} codePath A code path to get.\n+ * @returns {CodePathState} The state of the code path.\n+ *\/\n+ static getState(codePath) {\n+ return codePath.internal;\n+ }\n+\n+ \/**\n+ * The initial code path segment.\n+ * @type {CodePathSegment}\n+ *\/\n+ get initialSegment() {\n+ return this.internal.initialSegment;\n+ }\n+\n+ \/**\n+ * Final code path segments.\n+ * This array is a mix of `returnedSegments` and `thrownSegments`.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ get finalSegments() {\n+ return this.internal.finalSegments;\n+ }\n+\n+ \/**\n+ * Final code path segments which is with `return` statements.\n+ * This array contains the last path segment if it's reachable.\n+ * Since the reachable last path returns `undefined`.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ get returnedSegments() {\n+ return this.internal.returnedForkContext;\n+ }\n+\n+ \/**\n+ * Final code path segments which is with `throw` statements.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ get thrownSegments() {\n+ return this.internal.thrownForkContext;\n+ }\n+\n+ \/**\n+ * Current code path segments.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ get currentSegments() {\n+ return this.internal.currentSegments;\n+ }\n+\n+ \/**\n+ * Traverses all segments in this code path.\n+ *\n+ * codePath.traverseSegments(function(segment, controller) {\n+ * \/\/ do something.\n+ * });\n+ *\n+ * This method enumerates segments in order from the head.\n+ *\n+ * The `controller` object has two methods.\n+ *\n+ * - `controller.skip()` - Skip the following segments in this branch.\n+ * - `controller.break()` - Skip all following segments.\n+ * @param {Object} [options] Omittable.\n+ * @param {CodePathSegment} [options.first] The first segment to traverse.\n+ * @param {CodePathSegment} [options.last] The last segment to traverse.\n+ * @param {Function} callback A callback function.\n+ * @returns {void}\n+ *\/\n+ traverseSegments(options, callback) {\n+ let resolvedOptions;\n+ let resolvedCallback;\n+\n+ if (typeof options === 'function') {\n+ resolvedCallback = options;\n+ resolvedOptions = {};\n+ } else {\n+ resolvedOptions = options || {};\n+ resolvedCallback = callback;\n+ }\n+\n+ const startSegment = resolvedOptions.first || this.internal.initialSegment;\n+ const lastSegment = resolvedOptions.last;\n+\n+ let item = null;\n+ let index = 0;\n+ let end = 0;\n+ let segment = null;\n+ const visited = Object.create(null);\n+ const stack = [[startSegment, 0]];\n+ let skippedSegment = null;\n+ let broken = false;\n+ const controller = {\n+ skip() {\n+ if (stack.length <= 1) {\n+ broken = true;\n+ } else {\n+ skippedSegment = stack[stack.length - 2][0];\n+ }\n+ },\n+ break() {\n+ broken = true;\n+ },\n+ };\n+\n+ \/**\n+ * Checks a given previous segment has been visited.\n+ * @param {CodePathSegment} prevSegment A previous segment to check.\n+ * @returns {boolean} `true` if the segment has been visited.\n+ *\/\n+ function isVisited(prevSegment) {\n+ return (\n+ visited[prevSegment.id] || segment.isLoopedPrevSegment(prevSegment)\n+ );\n+ }\n+\n+ while (stack.length > 0) {\n+ item = stack[stack.length - 1];\n+ segment = item[0];\n+ index = item[1];\n+\n+ if (index === 0) {\n+ \/\/ Skip if this segment has been visited already.\n+ if (visited[segment.id]) {\n+ stack.pop();\n+ continue;\n+ }\n+\n+ \/\/ Skip if all previous segments have not been visited.\n+ if (\n+ segment !== startSegment &&\n+ segment.prevSegments.length > 0 &&\n+ !segment.prevSegments.every(isVisited)\n+ ) {\n+ stack.pop();\n+ continue;\n+ }\n+\n+ \/\/ Reset the flag of skipping if all branches have been skipped.\n+ if (skippedSegment && segment.prevSegments.includes(skippedSegment)) {\n+ skippedSegment = null;\n+ }\n+ visited[segment.id] = true;\n+\n+ \/\/ Call the callback when the first time.\n+ if (!skippedSegment) {\n+ resolvedCallback.call(this, segment, controller);\n+ if (segment === lastSegment) {\n+ controller.skip();\n+ }\n+ if (broken) {\n+ break;\n+ }\n+ }\n+ }\n+\n+ \/\/ Update the stack.\n+ end = segment.nextSegments.length - 1;\n+ if (index < end) {\n+ item[1] += 1;\n+ stack.push([segment.nextSegments[index], 0]);\n+ } else if (index === end) {\n+ item[0] = segment.nextSegments[index];\n+ item[1] = 0;\n+ } else {\n+ stack.pop();\n+ }\n+ }\n+ }\n+}\n+\n+module.exports = CodePath;\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/fork-context.js b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/fork-context.js\nnew file mode 100644\nindex 0000000000..528aaa41e1\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/fork-context.js\n@@ -0,0 +1,252 @@\n+'use strict';\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Requirements\n+\/\/------------------------------------------------------------------------------\n+\n+\/\/ eslint-disable-next-line\n+const assert = require('.\/assert');\n+\/\/ eslint-disable-next-line\n+const CodePathSegment = require('.\/code-path-segment');\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Helpers\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * Gets whether or not a given segment is reachable.\n+ * @param {CodePathSegment} segment A segment to get.\n+ * @returns {boolean} `true` if the segment is reachable.\n+ *\/\n+function isReachable(segment) {\n+ return segment.reachable;\n+}\n+\n+\/**\n+ * Creates new segments from the specific range of `context.segmentsList`.\n+ *\n+ * When `context.segmentsList` is `[[a, b], [c, d], [e, f]]`, `begin` is `0`, and\n+ * `end` is `-1`, this creates `[g, h]`. This `g` is from `a`, `c`, and `e`.\n+ * This `h` is from `b`, `d`, and `f`.\n+ * @param {ForkContext} context An instance.\n+ * @param {number} begin The first index of the previous segments.\n+ * @param {number} end The last index of the previous segments.\n+ * @param {Function} create A factory function of new segments.\n+ * @returns {CodePathSegment[]} New segments.\n+ *\/\n+function makeSegments(context, begin, end, create) {\n+ const list = context.segmentsList;\n+\n+ const normalizedBegin = begin >= 0 ? begin : list.length + begin;\n+ const normalizedEnd = end >= 0 ? end : list.length + end;\n+\n+ const segments = [];\n+\n+ for (let i = 0; i < context.count; ++i) {\n+ const allPrevSegments = [];\n+\n+ for (let j = normalizedBegin; j <= normalizedEnd; ++j) {\n+ allPrevSegments.push(list[j][i]);\n+ }\n+\n+ segments.push(create(context.idGenerator.next(), allPrevSegments));\n+ }\n+\n+ return segments;\n+}\n+\n+\/**\n+ * `segments` becomes doubly in a `finally` block. Then if a code path exits by a\n+ * control statement (such as `break`, `continue`) from the `finally` block, the\n+ * destination's segments may be half of the source segments. In that case, this\n+ * merges segments.\n+ * @param {ForkContext} context An instance.\n+ * @param {CodePathSegment[]} segments Segments to merge.\n+ * @returns {CodePathSegment[]} The merged segments.\n+ *\/\n+function mergeExtraSegments(context, segments) {\n+ let currentSegments = segments;\n+\n+ while (currentSegments.length > context.count) {\n+ const merged = [];\n+\n+ for (\n+ let i = 0, length = (currentSegments.length \/ 2) | 0;\n+ i < length;\n+ ++i\n+ ) {\n+ merged.push(\n+ CodePathSegment.newNext(context.idGenerator.next(), [\n+ currentSegments[i],\n+ currentSegments[i + length],\n+ ]),\n+ );\n+ }\n+ currentSegments = merged;\n+ }\n+ return currentSegments;\n+}\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Public Interface\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * A class to manage forking.\n+ *\/\n+class ForkContext {\n+ \/**\n+ * @param {IdGenerator} idGenerator An identifier generator for segments.\n+ * @param {ForkContext|null} upper An upper fork context.\n+ * @param {number} count A number of parallel segments.\n+ *\/\n+ constructor(idGenerator, upper, count) {\n+ this.idGenerator = idGenerator;\n+ this.upper = upper;\n+ this.count = count;\n+ this.segmentsList = [];\n+ }\n+\n+ \/**\n+ * The head segments.\n+ * @type {CodePathSegment[]}\n+ *\/\n+ get head() {\n+ const list = this.segmentsList;\n+\n+ return list.length === 0 ? [] : list[list.length - 1];\n+ }\n+\n+ \/**\n+ * A flag which shows empty.\n+ * @type {boolean}\n+ *\/\n+ get empty() {\n+ return this.segmentsList.length === 0;\n+ }\n+\n+ \/**\n+ * A flag which shows reachable.\n+ * @type {boolean}\n+ *\/\n+ get reachable() {\n+ const segments = this.head;\n+\n+ return segments.length > 0 && segments.some(isReachable);\n+ }\n+\n+ \/**\n+ * Creates new segments from this context.\n+ * @param {number} begin The first index of previous segments.\n+ * @param {number} end The last index of previous segments.\n+ * @returns {CodePathSegment[]} New segments.\n+ *\/\n+ makeNext(begin, end) {\n+ return makeSegments(this, begin, end, CodePathSegment.newNext);\n+ }\n+\n+ \/**\n+ * Creates new segments from this context.\n+ * The new segments is always unreachable.\n+ * @param {number} begin The first index of previous segments.\n+ * @param {number} end The last index of previous segments.\n+ * @returns {CodePathSegment[]} New segments.\n+ *\/\n+ makeUnreachable(begin, end) {\n+ return makeSegments(this, begin, end, CodePathSegment.newUnreachable);\n+ }\n+\n+ \/**\n+ * Creates new segments from this context.\n+ * The new segments don't have connections for previous segments.\n+ * But these inherit the reachable flag from this context.\n+ * @param {number} begin The first index of previous segments.\n+ * @param {number} end The last index of previous segments.\n+ * @returns {CodePathSegment[]} New segments.\n+ *\/\n+ makeDisconnected(begin, end) {\n+ return makeSegments(this, begin, end, CodePathSegment.newDisconnected);\n+ }\n+\n+ \/**\n+ * Adds segments into this context.\n+ * The added segments become the head.\n+ * @param {CodePathSegment[]} segments Segments to add.\n+ * @returns {void}\n+ *\/\n+ add(segments) {\n+ assert(\n+ segments.length >= this.count,\n+ `${segments.length} >= ${this.count}`,\n+ );\n+\n+ this.segmentsList.push(mergeExtraSegments(this, segments));\n+ }\n+\n+ \/**\n+ * Replaces the head segments with given segments.\n+ * The current head segments are removed.\n+ * @param {CodePathSegment[]} segments Segments to add.\n+ * @returns {void}\n+ *\/\n+ replaceHead(segments) {\n+ assert(\n+ segments.length >= this.count,\n+ `${segments.length} >= ${this.count}`,\n+ );\n+\n+ this.segmentsList.splice(-1, 1, mergeExtraSegments(this, segments));\n+ }\n+\n+ \/**\n+ * Adds all segments of a given fork context into this context.\n+ * @param {ForkContext} context A fork context to add.\n+ * @returns {void}\n+ *\/\n+ addAll(context) {\n+ assert(context.count === this.count);\n+\n+ const source = context.segmentsList;\n+\n+ for (let i = 0; i < source.length; ++i) {\n+ this.segmentsList.push(source[i]);\n+ }\n+ }\n+\n+ \/**\n+ * Clears all segments in this context.\n+ * @returns {void}\n+ *\/\n+ clear() {\n+ this.segmentsList = [];\n+ }\n+\n+ \/**\n+ * Creates the root fork context.\n+ * @param {IdGenerator} idGenerator An identifier generator for segments.\n+ * @returns {ForkContext} New fork context.\n+ *\/\n+ static newRoot(idGenerator) {\n+ const context = new ForkContext(idGenerator, null, 1);\n+\n+ context.add([CodePathSegment.newRoot(idGenerator.next())]);\n+\n+ return context;\n+ }\n+\n+ \/**\n+ * Creates an empty fork context preceded by a given context.\n+ * @param {ForkContext} parentContext The parent fork context.\n+ * @param {boolean} forkLeavingPath A flag which shows inside of `finally` block.\n+ * @returns {ForkContext} New fork context.\n+ *\/\n+ static newEmpty(parentContext, forkLeavingPath) {\n+ return new ForkContext(\n+ parentContext.idGenerator,\n+ parentContext,\n+ (forkLeavingPath ? 2 : 1) * parentContext.count,\n+ );\n+ }\n+}\n+\n+module.exports = ForkContext;\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/id-generator.js b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/id-generator.js\nnew file mode 100644\nindex 0000000000..ed0f47d834\n--- \/dev\/null\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/code-path-analysis\/id-generator.js\n@@ -0,0 +1,37 @@\n+'use strict';\n+\n+\/* eslint-disable react-internal\/safe-string-coercion *\/\n+\n+\/\/------------------------------------------------------------------------------\n+\/\/ Public Interface\n+\/\/------------------------------------------------------------------------------\n+\n+\/**\n+ * A generator for unique ids.\n+ *\/\n+class IdGenerator {\n+ \/**\n+ * @param {string} prefix Optional. A prefix of generated ids.\n+ *\/\n+ constructor(prefix) {\n+ this.prefix = String(prefix);\n+ this.n = 0;\n+ }\n+\n+ \/**\n+ * Generates id.\n+ * @returns {string} A generated id.\n+ *\/\n+ next() {\n+ this.n = (1 + this.n) | 0;\n+\n+ \/* c8 ignore start *\/\n+ if (this.n < 0) {\n+ this.n = 1;\n+ } \/* c8 ignore stop *\/\n+\n+ return this.prefix + this.n;\n+ }\n+}\n+\n+module.exports = IdGenerator;\ndiff --git a\/packages\/eslint-plugin-react-hooks\/src\/rules\/RulesOfHooks.ts b\/packages\/eslint-plugin-react-hooks\/src\/rules\/RulesOfHooks.ts\nindex 0ab0c5ff21..6be40df532 100644\n--- a\/packages\/eslint-plugin-react-hooks\/src\/rules\/RulesOfHooks.ts\n+++ b\/packages\/eslint-plugin-react-hooks\/src\/rules\/RulesOfHooks.ts\n@@ -9,6 +9,9 @@\n import type {Rule, Scope} from 'eslint';\n import type {CallExpression, DoWhileStatement, Node} from 'estree';\n \n+\/\/ @ts-expect-error untyped module\n+import CodePathAnalyzer from '..\/code-path-analysis\/code-path-analyzer';\n+\n \/**\n * Catch all identifiers that begin with \"use\" followed by an uppercase Latin\n * character to exclude identifiers like \"user\".\n@@ -184,9 +187,25 @@ const rule = {\n return getSourceCode().getScope(node);\n };\n \n- return {\n+ function hasFlowSuppression(node: Node, suppression: string) {\n+ const sourceCode = getSourceCode();\n+ const comments = sourceCode.getAllComments();\n+ const flowSuppressionRegex = new RegExp(\n+ '\\\\$FlowFixMe\\\\[' + suppression + '\\\\]',\n+ );\n+ return comments.some(\n+ commentNode =>\n+ flowSuppressionRegex.test(commentNode.value) &&\n+ commentNode.loc != null &&\n+ node.loc != null &&\n+ commentNode.loc.end.line === node.loc.start.line - 1,\n+ );\n+ }\n+\n+ const analyzer = new CodePathAnalyzer({\n \/\/ Maintain code segment path stack as we traverse.\n- onCodePathSegmentStart: segment => codePathSegmentStack.push(segment),\n+ onCodePathSegmentStart: (segment: Rule.CodePathSegment) =>\n+ codePathSegmentStack.push(segment),\n onCodePathSegmentEnd: () => codePathSegmentStack.pop(),\n \n \/\/ Maintain code path stack as we traverse.\n@@ -199,7 +218,7 @@ const rule = {\n \/\/\n \/\/ Everything is ok if all React Hooks are both reachable from the initial\n \/\/ segment and reachable from every final segment.\n- onCodePathEnd(codePath, codePathNode) {\n+ onCodePathEnd(codePath: any, codePathNode: Node) {\n const reactHooksMap = codePathReactHooksMapStack.pop();\n if (reactHooksMap?.size === 0) {\n return;\n@@ -508,6 +527,11 @@ const rule = {\n const cycled = cyclic.has(segment.id);\n \n for (const hook of reactHooks) {\n+ \/\/ Skip reporting if this hook already has a relevant flow suppression.\n+ if (hasFlowSuppression(hook, 'react-rule-hook')) {\n+ continue;\n+ }\n+\n \/\/ Report an error if a hook may be called more then once.\n \/\/ `use(...)` can be called in loops.\n if (\n@@ -611,6 +635,16 @@ const rule = {\n }\n }\n },\n+ });\n+\n+ return {\n+ '*'(node: any) {\n+ analyzer.enterNode(node);\n+ },\n+\n+ '*:exit'(node: any) {\n+ analyzer.leaveNode(node);\n+ },\n \n \/\/ Missed opportunity...We could visit all `Identifier`s instead of all\n \/\/ `CallExpression`s and check that _every use_ of a hook name is valid.\n@@ -696,6 +730,10 @@ const rule = {\n \n function getFunctionName(node: Node) {\n if (\n+ \/\/ @ts-expect-error parser-hermes produces these node types\n+ node.type === 'ComponentDeclaration' ||\n+ \/\/ @ts-expect-error parser-hermes produces these node types\n+ node.type === 'HookDeclaration' ||\n node.type === 'FunctionDeclaration' ||\n (node.type === 'FunctionExpression' && node.id)\n ) {\n","commit":{"subject":"[eslint-plugin-react-hooks] updates for component syntax (#33089)","revision":"4c4a57c4f9f7f7d44e4cbe868c066e3691cd4038","shortRevision":"4c4a57c4f9","authorName":"Jan Kassens","authorEmail":"jkassens@meta.com","authoredAt":"2025-05-02T15:04:45-04:00"},"body":"Adds support for Flow's component and hook syntax.\n[docs](https:\/\/flow.org\/en\/docs\/react\/component-syntax\/)","parents":["dc2b11817bbfcd39f1dbdc8945acbf18cb5e41c3"]}

dillon1000/react

Files changed