eslint-plugin-maintainability 3.0.9 → 3.0.10

package/src/rules/error-handling/no-silent-errors.js

@@ -1,41 +1,26 @@
 "use strict";
-/**
- * Copyright (c) 2025 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noSilentErrors = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
-/**
- * Check if catch block is empty or only has comments
- */
 function isEmptyCatchBlock(catchClause) {
     const body = catchClause.body;
     if (!body || body.type !== 'BlockStatement') {
         return true;
     }
-    // Check if body only has comments or is empty
     const statements = body.body;
     if (statements.length === 0) {
         return true;
     }
-    // Check if all statements are just comments (not possible in AST, but check for empty statements)
     const nonEmptyStatements = statements.filter((stmt) => stmt.type !== 'EmptyStatement');
     return nonEmptyStatements.length === 0;
 }
-/**
- * Check if catch block has a comment explaining why it's empty
- */
 function hasExplanatoryComment(catchClause, sourceCode) {
-    // Check for comments before the catch clause
     const comments = sourceCode.getAllComments();
     const catchStart = catchClause.loc?.start;
     if (!catchStart || !comments.length) {
         return false;
     }
-    // Look for explanatory comments near the catch clause
     const explanatoryPatterns = [
         /intentional/i,
         /expected/i,
@@ -53,7 +38,6 @@ function hasExplanatoryComment(catchClause, sourceCode) {
         /todo/i,
         /fixme/i,
     ];
-    // Check comments before the catch clause (within 2 lines)
     for (const comment of comments) {
         if (comment.loc && catchStart.line - comment.loc.end.line <= 2) {
             const commentText = comment.value.toLowerCase();
@@ -140,14 +124,10 @@ exports.noSilentErrors = (0, eslint_devkit_2.createRule)({
             return {};
         }
         const sourceCode = context.sourceCode;
-        /**
-         * Check catch clauses
-         */
         function checkCatchClause(node) {
             if (!isEmptyCatchBlock(node)) {
                 return;
             }
-            // Check if comment explains why it's empty
             if (allowWithComment && hasExplanatoryComment(node, sourceCode)) {
                 return;
             }
@@ -157,7 +137,7 @@ exports.noSilentErrors = (0, eslint_devkit_2.createRule)({
                 suggest: [
                     {
                         messageId: 'addErrorLogging',
-                        fix: () => null, // Cannot auto-fix without context
+                        fix: () => null,
                     },
                     {
                         messageId: 'addErrorHandling',

package/src/rules/error-handling/no-unhandled-promise.js

@@ -1,9 +1,4 @@
 "use strict";
-/**
- * Copyright (c) 2025 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnhandledPromise = void 0;
 exports.isPromiseExpression = isPromiseExpression;
@@ -11,26 +6,15 @@ exports.isInsidePromiseCallback = isInsidePromiseCallback;
 exports.isPromiseHandled = isPromiseHandled;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
 const eslint_devkit_2 = require("@interlace/eslint-devkit");
-/**
- * Check if a node is a Promise-like expression
- * For now, we check all CallExpressions since we can't statically determine
- * which functions return promises. The isPromiseHandled function will filter out
- * non-promise calls that are inside handled promise chains.
- */
 function isPromiseExpression(node) {
-    // Function calls that might return promises
     if (node.type === 'CallExpression') {
         return true;
     }
-    // Await expressions (already handled)
     if (node.type === 'AwaitExpression') {
-        return false; // Already handled
+        return false;
     }
     return false;
 }
-/**
- * Check if a CallExpression is inside a promise chain callback
- */
 function isInsidePromiseCallback(node) {
     let current = node;
     let depth = 0;
@@ -40,10 +24,8 @@ function isInsidePromiseCallback(node) {
             .parent;
         if (!parent)
             break;
-        // Check if we're inside an arrow function or function expression
         if (parent.type === 'ArrowFunctionExpression' ||
             parent.type === 'FunctionExpression') {
-            // Check if this function is an argument to a promise method (.then, .catch, .finally)
             const funcParent = parent
                 .parent;
             if (funcParent &&
@@ -56,7 +38,6 @@ function isInsidePromiseCallback(node) {
                     if (methodName === 'then' ||
                         methodName === 'catch' ||
                         methodName === 'finally') {
-                        // We're inside a promise chain callback
                         return true;
                     }
                 }
@@ -67,11 +48,7 @@ function isInsidePromiseCallback(node) {
     }
     return false;
 }
-/**
- * Check if promise is handled (has .catch, .then, or is in try/catch)
- */
 function isPromiseHandled(node) {
-    // For identifiers, check if they're used in a promise chain
     if (node.type === 'Identifier') {
         const parent = node.parent;
         if (parent &&
@@ -82,19 +59,16 @@ function isPromiseHandled(node) {
                 if (methodName === 'catch' ||
                     methodName === 'then' ||
                     methodName === 'finally') {
-                    // Check if this MemberExpression is used as a callee (called)
                     const memberParent = parent.parent;
                     if (memberParent &&
                         memberParent.type === 'CallExpression' &&
                         memberParent.callee === parent) {
-                        // Promise is handled by .then(), .catch(), or .finally()
                         return true;
                     }
                 }
             }
         }
     }
-    // For CallExpressions, traverse up the AST to find if this promise is part of a handled chain
     let current = node;
     let depth = 0;
     const maxDepth = 10;
@@ -103,29 +77,24 @@ function isPromiseHandled(node) {
             .parent;
         if (!parent)
             break;
-        // Check if parent is a MemberExpression with .catch/.then/.finally
         if (parent.type === 'MemberExpression' && parent.object === current) {
             if (parent.property.type === 'Identifier') {
                 const methodName = parent.property.name;
                 if (methodName === 'catch' ||
                     methodName === 'then' ||
                     methodName === 'finally') {
-                    // Check if this MemberExpression is used as a callee (called)
                     const memberParent = parent.parent;
                     if (memberParent &&
                         memberParent.type === 'CallExpression' &&
                         memberParent.callee === parent) {
-                        // Promise is handled by .then(), .catch(), or .finally()
                         return true;
                     }
                 }
             }
         }
-        // Check if in try/catch block
         if (parent.type === 'TryStatement') {
             return true;
         }
-        // Check if in await expression
         if (parent.type === 'AwaitExpression') {
             return true;
         }
@@ -212,49 +181,37 @@ exports.noUnhandledPromise = (0, eslint_devkit_2.createRule)({
         if (isTestFile) {
             return {};
         }
-        // const sourceCode = context.sourceCode; // Not used
-        /**
-         * Check call expressions for unhandled promises
-         */
         function checkCallExpression(node) {
-            // Skip CallExpressions that are inside promise chain callbacks
             if (isInsidePromiseCallback(node)) {
                 return;
             }
-            // Skip calls to promise methods (.then, .catch, .finally) as they are handled by definition
-            // But only if they have meaningful callbacks
             if (node.callee.type === 'MemberExpression' &&
                 node.callee.property.type === 'Identifier') {
                 const methodName = node.callee.property.name;
                 if (methodName === 'then' ||
                     methodName === 'catch' ||
                     methodName === 'finally') {
-                    // Check if the callback is empty or meaningless
                     if (node.arguments.length > 0 &&
                         node.arguments[0].type === 'ArrowFunctionExpression') {
                         const callback = node.arguments[0];
                         if (callback.body.type === 'BlockStatement' &&
                             callback.body.body.length === 0) {
-                            // Empty callback - don't skip, this should be flagged
                         }
                         else {
-                            return; // Has meaningful callback, skip
+                            return;
                         }
                     }
                     else {
-                        return; // Not an arrow function callback, assume it's handled
+                        return;
                     }
                 }
             }
-            // Check if it's a promise-returning function
             if (!isPromiseExpression(node)) {
                 return;
             }
-            // Check if it's already handled
             if (isPromiseHandled(node)) {
                 return;
             }
-            // Check if it's in a void expression
             if (ignoreVoidExpressions) {
                 const parent = node
                     .parent;
@@ -264,13 +221,9 @@ exports.noUnhandledPromise = (0, eslint_devkit_2.createRule)({
                     return;
                 }
             }
-            // Skip if this CallExpression is an argument to another CallExpression
-            // (e.g., console.log(fetch(url)) - we don't want to flag fetch(url) here)
             const parent = node
                 .parent;
             if (parent && parent.type === 'CallExpression') {
-                // Only skip if it's not part of a promise chain
-                // If it's the object of a MemberExpression with .then/.catch/.finally, it's a promise
                 const grandParent = parent.parent;
                 if (!(grandParent &&
                     grandParent.type === 'MemberExpression' &&
@@ -288,7 +241,7 @@ exports.noUnhandledPromise = (0, eslint_devkit_2.createRule)({
                 suggest: [
                     {
                         messageId: 'addCatch',
-                        fix: () => null, // Cannot auto-fix without context
+                        fix: () => null,
                     },
                     {
                         messageId: 'useTryCatch',
@@ -301,55 +254,6 @@ exports.noUnhandledPromise = (0, eslint_devkit_2.createRule)({
                 ],
             });
         }
-        /**
-         * Check identifier expressions for unhandled promises
-         * Note: Currently unused, keeping for future implementation
-         */
-        /*
-        function checkIdentifier(node: TSESTree.Identifier) {
-          // Skip identifiers that are inside promise chain callbacks
-          if (isInsidePromiseCallback({ type: 'CallExpression', callee: node, arguments: [], optional: false } as TSESTree.CallExpression)) {
-            return;
-          }
-    
-          // Check if it's a promise-like identifier
-          if (!isPromiseExpression(node)) {
-            return;
-          }
-    
-          // Check if it's already handled
-          if (isPromiseHandled(node)) {
-            return;
-          }
-    
-          // Check if it's in a void expression
-          if (ignoreVoidExpressions) {
-            const parent = (node as TSESTree.Node & { parent?: TSESTree.Node }).parent;
-            if (parent && parent.type === 'UnaryExpression' && parent.operator === 'void') {
-              return;
-            }
-          }
-    
-          context.report({
-            node,
-            messageId: 'unhandledPromise',
-            suggest: [
-              {
-                messageId: 'addCatch',
-                fix: () => null,
-              },
-              {
-                messageId: 'useTryCatch',
-                fix: () => null,
-              },
-              {
-                messageId: 'useAwait',
-                fix: () => null,
-              },
-            ],
-          });
-        }
-        */
         return {
             CallExpression: checkCallExpression,
         };

package/src/rules/maintainability/cognitive-complexity.js

@@ -1,9 +1,4 @@
 "use strict";
-/**
- * Copyright (c) 2025 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cognitiveComplexity = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
@@ -20,7 +15,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
             cvss: 7.5,
         },
         messages: {
-            // 🎯 Token optimization: 40% reduction (60→36 tokens) - keeps complexity metrics inline
             highCognitiveComplexity: (0, eslint_devkit_1.formatLLMMessage)({
                 icon: eslint_devkit_1.MessageIcons.COMPLEXITY,
                 issueName: 'High cognitive complexity',
@@ -82,10 +76,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
     create(context) {
         const { maxComplexity = 15 } = context.options[0] || {};
         const filename = context.filename;
-        /**
-         * Calculate cognitive complexity for a function
-         * Based on SonarQube's cognitive complexity algorithm
-         */
         function calculateCognitiveComplexity(node) {
             let complexity = 0;
             const breakdown = {
@@ -101,27 +91,22 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                 ? node.id.name
                 : 'anonymous';
             function traverse(n, currentNesting) {
-                // Increment for conditionals
                 if (n.type === 'IfStatement') {
                     complexity += 1 + currentNesting;
                     breakdown.conditionals++;
-                    // Traverse the test condition to count logical operators
                     traverse(n.test, currentNesting);
                     traverse(n.consequent, currentNesting + 1);
                     if (n.alternate) {
                         if (n.alternate.type === 'IfStatement') {
-                            // else if doesn't increase nesting
                             traverse(n.alternate, currentNesting);
                         }
                         else {
-                            // else increases nesting
                             complexity += 1;
                             traverse(n.alternate, currentNesting + 1);
                         }
                     }
                     return;
                 }
-                // Loops
                 if (n.type === 'ForStatement' ||
                     n.type === 'ForInStatement' ||
                     n.type === 'ForOfStatement' ||
@@ -152,7 +137,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                     }
                     return;
                 }
-                // Switch
                 if (n.type === 'SwitchStatement') {
                     complexity += 1 + currentNesting;
                     breakdown.switches++;
@@ -160,7 +144,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                     n.cases.forEach((c) => traverse(c, currentNesting + 1));
                     return;
                 }
-                // Logical operators (short-circuiting)
                 if (n.type === 'LogicalExpression') {
                     if (n.operator === '&&' ||
                         n.operator === '||' ||
@@ -169,19 +152,16 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                         breakdown.logicalOperators++;
                     }
                 }
-                // Catch clauses
                 if (n.type === 'CatchClause') {
                     complexity += 1 + currentNesting;
                     breakdown.catches++;
                     traverse(n.body, currentNesting + 1);
                     return;
                 }
-                // Ternary operators
                 if (n.type === 'ConditionalExpression') {
                     complexity += 1 + currentNesting;
                     breakdown.conditionals++;
                 }
-                // Recursion
                 if (n.type === 'CallExpression') {
                     if (n.callee.type === 'Identifier' &&
                         n.callee.name === functionName) {
@@ -189,17 +169,12 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                         breakdown.recursion++;
                     }
                 }
-                // Update max nesting
                 if (n.type === 'BlockStatement' ||
                     n.type === 'FunctionDeclaration' ||
                     n.type === 'FunctionExpression' ||
                     n.type === 'ArrowFunctionExpression') {
                     breakdown.nesting = Math.max(breakdown.nesting, currentNesting);
                 }
-                /**
-                 * Traverse children - use a visited set to prevent infinite recursion
-                 * Only traverse specific AST child properties, not all object properties
-                 */
                 const visited = new Set();
                 function traverseChild(child) {
                     if (child && typeof child === 'object' && 'type' in child) {
@@ -210,7 +185,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                         }
                     }
                 }
-                // Known child properties based on ESTree spec
                 const childKeys = [
                     'body',
                     'test',
@@ -238,7 +212,7 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                     'handler',
                     'block',
                     'finalizer',
-                ]; // handler for TryStatement.catch, block/finalizer for TryStatement
+                ];
                 for (const key of childKeys) {
                     const child = n[key];
                     if (child) {
@@ -256,12 +230,8 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
             }
             return { total: complexity, breakdown };
         }
-        /**
-         * Analyze function and suggest extractions
-         */
         function suggestExtractions(node, breakdown) {
             const suggestions = [];
-            // Suggest extracting deeply nested logic
             if (breakdown.nesting >= 4 && node.loc) {
                 suggestions.push({
                     name: 'extractNestedLogic',
@@ -270,7 +240,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                     estimatedComplexityReduction: Math.floor(breakdown.nesting * 1.5),
                 });
             }
-            // Suggest extracting switch/case logic
             if (breakdown.switches >= 2 && node.loc) {
                 suggestions.push({
                     name: 'refactorSwitchToStrategy',
@@ -279,7 +248,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                     estimatedComplexityReduction: breakdown.switches * 2,
                 });
             }
-            // Suggest extracting loop logic
             if (breakdown.loops >= 3 && node.loc) {
                 suggestions.push({
                     name: 'extractLoopLogic',
@@ -288,7 +256,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                     estimatedComplexityReduction: breakdown.loops * 2,
                 });
             }
-            // Suggest simplifying conditionals
             if (breakdown.conditionals >= 5 && node.loc) {
                 suggestions.push({
                     name: 'simplifyConditionals',
@@ -299,10 +266,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
             }
             return suggestions;
         }
-        /**
-         * Suggest architectural patterns
-         */
-        // oxlint-disable-next-line consistent-function-scoping
         function suggestPattern(breakdown) {
             if (breakdown.switches >= 2)
                 return 'Strategy Pattern';
@@ -314,11 +277,8 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                 return 'Extract Method + Composed Functions';
             return 'Extract Method';
         }
-        /**
-         * Calculate estimated refactoring time
-         */
         function estimateRefactoringTime(complexity, breakdown) {
-            const baseTime = Math.floor((complexity - maxComplexity) * 3); // 3 minutes per point
+            const baseTime = Math.floor((complexity - maxComplexity) * 3);
             const nestingPenalty = breakdown.nesting >= 4 ? 15 : 0;
             const totalMinutes = baseTime + nestingPenalty;
             if (totalMinutes < 30)
@@ -327,9 +287,6 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                 return '30-60 minutes';
             return `${Math.ceil(totalMinutes / 60)} hours`;
         }
-        /**
-         * Check function complexity
-         */
         function checkFunction(node) {
             const { total: complexity, breakdown } = calculateCognitiveComplexity(node);
             if (complexity <= maxComplexity)
@@ -369,7 +326,7 @@ exports.cognitiveComplexity = (0, eslint_devkit_2.createRule)({
                                 pattern,
                                 reduction: String(suggestion.estimatedComplexityReduction),
                             },
-                            fix: () => null, // Complex refactoring, cannot auto-fix
+                            fix: () => null,
                         };
                     })
                     : undefined,

package/src/rules/maintainability/consistent-function-scoping.js

@@ -1,9 +1,4 @@
 "use strict";
-/**
- * Copyright (c) 2025 Ofri Peretz
- * Licensed under the MIT License. Use of this source code is governed by the
- * MIT license that can be found in the LICENSE file.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.consistentFunctionScoping = void 0;
 const eslint_devkit_1 = require("@interlace/eslint-devkit");
@@ -52,7 +47,6 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
     create(context) {
         const [options] = context.options;
         const { checkArrowFunctions = true } = options || {};
-        // Track variables declared in each scope
         const scopeStack = [new Set()];
         function enterScope() {
             scopeStack.push(new Set());
@@ -77,28 +71,13 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
             return outerVars;
         }
         function analyzeFunction(node) {
-            // Skip module-level functions (direct children of Program or ExportNamedDeclaration)
             if (node.parent?.type === 'Program' || node.parent?.type === 'ExportNamedDeclaration' || node.parent?.type === 'ExportDefaultDeclaration') {
                 return;
             }
-            // Class methods / class field initializers — these are bound to the
-            // instance and cannot be moved to module scope. The parent chain is
-            // `MethodDefinition` (regular methods) or `PropertyDefinition` (class
-            // fields). Without this exemption, every method that doesn't reference
-            // `this` is wrongly flagged.
             const p = node.parent;
             if (p?.type === 'MethodDefinition' || p?.type === 'PropertyDefinition') {
                 return;
             }
-            // Inline callbacks passed to higher-order methods. These functions are
-            // inline BY DESIGN — moving `arr.reduce((a, b) => a + b)` to a
-            // top-level named function loses inline locality without improving
-            // anything. Common high-arity hosts:
-            //   - Array methods: map, filter, reduce, forEach, find, some, every, sort, flatMap
-            //   - Promise: .then, .catch, .finally
-            //   - Event hosts: .on('event', ...), addEventListener('event', ...)
-            //   - Scheduler: setTimeout, setInterval, requestAnimationFrame
-            //   - Promise constructor: `new Promise((resolve, reject) => ...)`
             if (p?.type === 'CallExpression') {
                 const callee = p.callee;
                 if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier') {
@@ -120,16 +99,13 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
                         return;
                 }
             }
-            // `new Promise((resolve, reject) => ...)` — executor must stay inline.
             if (p?.type === 'NewExpression' &&
                 p.callee.type === 'Identifier' &&
                 p.callee.name === 'Promise') {
                 return;
             }
-            // Get all variables referenced in the function body
             const referencedVars = new Set();
             function collectReferences(astNode, depth = 0, visited = new Set()) {
-                // Prevent infinite recursion
                 if (depth > 10 || visited.has(astNode)) {
                     return;
                 }
@@ -137,7 +113,6 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
                 if (astNode.type === 'Identifier') {
                     referencedVars.add(astNode.name);
                 }
-                // Recursively check all child nodes with depth limit
                 if (depth < 10) {
                     for (const key in astNode) {
                         const child = astNode[key];
@@ -150,31 +125,24 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
                                 });
                             }
                             else if ('type' in child) {
-                                // Outer `child && typeof child === 'object'` already guarantees
-                                // a non-null object here (CodeQL: `js/comparison-between-incompatible-types`).
                                 collectReferences(child, depth + 1, visited);
                             }
                         }
                     }
                 }
             }
-            // Collect all references in the function body
             if (node.body.type === 'BlockStatement') {
                 node.body.body.forEach((stmt) => collectReferences(stmt));
             }
             else {
-                // Arrow function with expression body
                 collectReferences(node.body);
             }
-            // Check function parameters
             node.params.forEach((param) => {
                 if (param.type === 'Identifier') {
                     referencedVars.add(param.name);
                 }
             });
-            // Get variables from outer scopes
             const outerVars = getOuterScopeVariables();
-            // Check if function captures any outer variables
             let capturesOuterVar = false;
             for (const ref of referencedVars) {
                 if (outerVars.has(ref)) {
@@ -182,9 +150,7 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
                     break;
                 }
             }
-            // If function doesn't capture any outer variables, it can be moved up
             if (!capturesOuterVar) {
-                // Additional check: ensure function name doesn't conflict at module scope
                 const functionName = node.type === 'FunctionDeclaration' ? node.id?.name : undefined;
                 const moduleScope = scopeStack[0];
                 if (!functionName || !moduleScope.has(functionName)) {
@@ -198,11 +164,6 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
                             {
                                 messageId: 'moveToModuleScope',
                                 fix(fixer) {
-                                    // This is a complex fix that would require:
-                                    // 1. Finding the module scope location
-                                    // 2. Moving the function declaration33 3
-                                    // 3. Updating any references
-                                    // For now, just provide a suggestion
                                     return fixer.insertTextBefore(node, '// TODO: Move this function to module scope - it doesn\'t capture outer variables\n');
                                 },
                             },
@@ -220,7 +181,6 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
             },
             FunctionDeclaration(node) {
                 enterScope();
-                // Add function parameters to the current scope
                 node.params.forEach((param) => {
                     if (param.type === 'Identifier') {
                         addVariableToCurrentScope(param.name);
@@ -233,14 +193,11 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
             },
             FunctionExpression(node) {
                 enterScope();
-                // Add function parameters to the current scope
                 node.params.forEach((param) => {
                     if (param.type === 'Identifier') {
                         addVariableToCurrentScope(param.name);
                     }
                 });
-                // Only check function expressions if they are assigned to variables
-                // (not just used as callbacks)
                 analyzeFunction(node);
             },
             'FunctionExpression:exit'() {
@@ -248,7 +205,6 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
             },
             ArrowFunctionExpression(node) {
                 enterScope();
-                // Add function parameters to the current scope
                 node.params.forEach((param) => {
                     if (param.type === 'Identifier') {
                         addVariableToCurrentScope(param.name);
@@ -262,7 +218,6 @@ exports.consistentFunctionScoping = (0, eslint_devkit_1.createRule)({
                 exitScope();
             },
             VariableDeclaration(node) {
-                // Add variables to current scope
                 node.declarations.forEach((decl) => {
                     if (decl.id.type === 'Identifier') {
                         addVariableToCurrentScope(decl.id.name);