@sun-asterisk/sunlint 1.2.2 → 1.3.1

package/rules/common/C029_catch_block_logging/dataflow-analyzer.js

@@ -1,454 +0,0 @@
-/**
- * C029 Data Flow Analyzer - IDE-Level Detection
- * 
- * Uses Control Flow Graph and Data Flow Analysis to detect unused error variables
- * Similar to how IDEs detect unused variables with gray highlighting
- */
-
-const astRegistry = require('../../../core/ast-modules');
-
-class C029DataFlowAnalyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Data Flow Enhanced Catch Block Analysis';
-    this.description = 'IDE-level detection of unused error variables in catch blocks';
-    this.astRegistry = astRegistry;
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    console.log(`🧠 C029 Data Flow: Analyzing ${files.length} files with IDE-level detection...`);
-
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🧠 Data Flow analyzing ${path.basename(filePath)}`);
-      }
-
-      try {
-        const content = require('fs').readFileSync(filePath, 'utf8');
-        const fileLanguage = this.getLanguageFromPath(filePath);
-        
-        // Parse with full AST
-        const ast = await this.parseAST(content, fileLanguage, filePath);
-        
-        if (ast) {
-          const dataFlowViolations = this.analyzeDataFlow(ast, filePath, content);
-          violations.push(...dataFlowViolations);
-        }
-
-      } catch (error) {
-        console.warn(`C029 Data Flow skipping ${filePath}: ${error.message}`);
-      }
-    }
-
-    return violations;
-  }
-
-  async parseAST(content, language, filePath) {
-    try {
-      if (!this.astRegistry || !this.astRegistry.parseCode) {
-        return null;
-      }
-      
-      return await this.astRegistry.parseCode(content, language, filePath);
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Core Data Flow Analysis - IDE-level detection
-   */
-  analyzeDataFlow(ast, filePath, content) {
-    const violations = [];
-    const isTestFile = this.isTestFile(filePath);
-    
-    // Find all catch clauses in the AST
-    const catchClauses = this.findCatchClauses(ast);
-    
-    for (const catchClause of catchClauses) {
-      const analysis = this.analyzeCatchClauseDataFlow(catchClause, ast, filePath, isTestFile);
-      
-      if (analysis.isViolation) {
-        violations.push({
-          ruleId: this.ruleId,
-          file: filePath,
-          line: catchClause.loc ? catchClause.loc.start.line : 1,
-          column: catchClause.loc ? catchClause.loc.start.column + 1 : 1,
-          message: analysis.message,
-          severity: analysis.severity,
-          code: this.getCodeFromNode(catchClause, content),
-          type: analysis.type,
-          confidence: analysis.confidence,
-          suggestion: analysis.suggestion
-        });
-      }
-    }
-    
-    return violations;
-  }
-
-  /**
-   * Find all catch clauses using AST traversal
-   */
-  findCatchClauses(ast) {
-    const catchClauses = [];
-    
-    const visitor = {
-      visitCatchClause: (node) => {
-        catchClauses.push(node);
-        return true; // Continue traversal
-      }
-    };
-    
-    this.traverseAST(ast, visitor);
-    return catchClauses;
-  }
-
-  /**
-   * Data Flow Analysis for single catch clause
-   * Similar to IDE unused variable detection
-   */
-  analyzeCatchClauseDataFlow(catchClause, ast, filePath, isTestFile) {
-    const errorParam = catchClause.param;
-    const catchBody = catchClause.body;
-    
-    // 1. No error parameter - likely intentional ignore
-    if (!errorParam) {
-      return { isViolation: false, reason: 'no_param' };
-    }
-    
-    // 2. Check for explicit ignore patterns
-    if (this.isExplicitlyIgnored(errorParam)) {
-      return { isViolation: false, reason: 'explicitly_ignored' };
-    }
-    
-    // 3. Empty catch block
-    if (!catchBody || !catchBody.body || catchBody.body.length === 0) {
-      return {
-        isViolation: true,
-        type: 'empty_catch_block',
-        message: 'Empty catch block - error is silently ignored',
-        severity: 'error',
-        confidence: 1.0,
-        suggestion: 'Add error logging or explicit ignore comment'
-      };
-    }
-    
-    // 4. DATA FLOW ANALYSIS - Track error variable usage
-    const errorUsage = this.analyzeErrorVariableUsage(errorParam, catchBody, isTestFile);
-    
-    if (!errorUsage.isUsed) {
-      return {
-        isViolation: true,
-        type: 'unused_error_variable',
-        message: `Error variable '${errorParam.name}' is declared but never used - silent error handling`,
-        severity: 'error',
-        confidence: 0.95,
-        suggestion: 'Use the error variable for logging/handling or rename to indicate intentional ignore'
-      };
-    }
-    
-    if (errorUsage.isUsedButNotProcessed) {
-      return {
-        isViolation: true,
-        type: 'error_not_processed',
-        message: `Error variable '${errorParam.name}' is referenced but not processed - may hide bugs`,
-        severity: 'warning',
-        confidence: 0.8,
-        suggestion: 'Ensure error is properly logged, handled, or rethrown'
-      };
-    }
-    
-    return { isViolation: false, reason: 'properly_handled' };
-  }
-
-  /**
-   * IDE-Level Error Variable Usage Analysis
-   * Tracks how error variable is used within catch block
-   */
-  analyzeErrorVariableUsage(errorParam, catchBody, isTestFile) {
-    const errorName = errorParam.name;
-    const usageAnalysis = {
-      isUsed: false,
-      isUsedButNotProcessed: false,
-      usageTypes: [],
-      references: []
-    };
-    
-    // Find all references to error variable
-    const references = this.findVariableReferences(errorName, catchBody);
-    usageAnalysis.references = references;
-    usageAnalysis.isUsed = references.length > 0;
-    
-    if (!usageAnalysis.isUsed) {
-      return usageAnalysis;
-    }
-    
-    // Analyze each reference to determine if error is processed
-    for (const ref of references) {
-      const usageType = this.categorizeErrorUsage(ref, isTestFile);
-      usageAnalysis.usageTypes.push(usageType);
-    }
-    
-    // Determine if error is properly processed
-    const hasValidProcessing = usageAnalysis.usageTypes.some(type => 
-      ['logging', 'rethrowing', 'test_assertion', 'error_handling', 'redux_thunk'].includes(type)
-    );
-    
-    const hasOnlyTrivialUsage = usageAnalysis.usageTypes.every(type => 
-      ['property_access', 'function_param', 'unused_assignment'].includes(type)
-    );
-    
-    if (hasOnlyTrivialUsage) {
-      usageAnalysis.isUsedButNotProcessed = true;
-    }
-    
-    return usageAnalysis;
-  }
-
-  /**
-   * Find all references to a variable within AST node
-   * Similar to IDE "Find All References"
-   */
-  findVariableReferences(variableName, node) {
-    const references = [];
-    
-    const visitor = {
-      visitIdentifier: (identifierNode) => {
-        if (identifierNode.name === variableName) {
-          references.push(identifierNode);
-        }
-        return true;
-      }
-    };
-    
-    this.traverseAST(node, visitor);
-    return references;
-  }
-
-  /**
-   * Categorize how error variable is being used
-   * Determines if usage is meaningful or trivial
-   */
-  categorizeErrorUsage(referenceNode, isTestFile) {
-    const parent = referenceNode.parent;
-    
-    if (!parent) return 'unknown';
-    
-    // Check parent node type to understand usage context
-    switch (parent.type) {
-      case 'ThrowStatement':
-        return 'rethrowing';
-        
-      case 'CallExpression':
-        // Check if it's a logging call
-        if (this.isLoggingCall(parent)) {
-          return 'logging';
-        }
-        // Check if it's test assertion
-        if (isTestFile && this.isTestAssertion(parent)) {
-          return 'test_assertion';
-        }
-        // Check if it's error handler call
-        if (this.isErrorHandlerCall(parent)) {
-          return 'error_handling';
-        }
-        // Check if it's Redux thunk
-        if (this.isReduxThunkCall(parent)) {
-          return 'redux_thunk';
-        }
-        return 'function_param';
-        
-      case 'MemberExpression':
-        // Accessing error properties (e.message, e.stack)
-        if (parent.object === referenceNode) {
-          return 'property_access';
-        }
-        return 'member_access';
-        
-      case 'AssignmentExpression':
-        return 'assignment';
-        
-      case 'ReturnStatement':
-        return 'return_value';
-        
-      default:
-        return 'other_usage';
-    }
-  }
-
-  /**
-   * Check if call expression is logging
-   */
-  isLoggingCall(callNode) {
-    if (callNode.type !== 'CallExpression') return false;
-    
-    const callee = callNode.callee;
-    
-    // console.error, console.log, etc.
-    if (callee.type === 'MemberExpression' && 
-        callee.object && callee.object.name === 'console') {
-      return ['log', 'error', 'warn', 'debug'].includes(callee.property.name);
-    }
-    
-    // logger.error, log.error, etc.
-    if (callee.type === 'MemberExpression' && 
-        callee.property && ['error', 'warn', 'log'].includes(callee.property.name)) {
-      return true;
-    }
-    
-    return false;
-  }
-
-  /**
-   * Check if call expression is test assertion
-   */
-  isTestAssertion(callNode) {
-    if (callNode.type !== 'CallExpression') return false;
-    
-    const callee = callNode.callee;
-    
-    // expect() calls
-    if (callee.name === 'expect') return true;
-    
-    // assert() calls
-    if (callee.name === 'assert') return true;
-    
-    // should() calls
-    if (callee.type === 'MemberExpression' && 
-        callee.property && callee.property.name === 'should') {
-      return true;
-    }
-    
-    return false;
-  }
-
-  /**
-   * Check if call expression is error handler
-   */
-  isErrorHandlerCall(callNode) {
-    if (callNode.type !== 'CallExpression') return false;
-    
-    const callee = callNode.callee;
-    if (callee.type === 'Identifier') {
-      const name = callee.name.toLowerCase();
-      return name.includes('handle') || name.includes('process') || 
-             name.includes('report') || name.includes('track');
-    }
-    
-    return false;
-  }
-
-  /**
-   * Check if call expression is Redux thunk pattern
-   */
-  isReduxThunkCall(callNode) {
-    if (callNode.type !== 'CallExpression') return false;
-    
-    const callee = callNode.callee;
-    if (callee.type === 'Identifier') {
-      return ['rejectWithValue', 'dispatch', 'handleAxiosError'].includes(callee.name);
-    }
-    
-    return false;
-  }
-
-  /**
-   * Check for explicit ignore patterns
-   */
-  isExplicitlyIgnored(errorParam) {
-    if (!errorParam || !errorParam.name) return false;
-    
-    const name = errorParam.name.toLowerCase();
-    
-    // Common ignore patterns
-    const ignorePatterns = ['_', 'ignored', 'ignore', 'unused'];
-    return ignorePatterns.includes(name);
-  }
-
-  /**
-   * Test file detection
-   */
-  isTestFile(filePath) {
-    const testPatterns = [
-      '__tests__', '.test.', '.spec.', '/test/', '/tests/',
-      'test-', 'spec-', '.test/', '.spec/'
-    ];
-    
-    return testPatterns.some(pattern => filePath.includes(pattern));
-  }
-
-  /**
-   * Get source code from AST node
-   */
-  getCodeFromNode(node, content) {
-    if (!node.loc) return '';
-    
-    const lines = content.split('\n');
-    const startLine = node.loc.start.line - 1;
-    const endLine = node.loc.end.line - 1;
-    
-    if (startLine === endLine) {
-      return lines[startLine].slice(node.loc.start.column, node.loc.end.column);
-    }
-    
-    const result = [lines[startLine].slice(node.loc.start.column)];
-    for (let i = startLine + 1; i < endLine; i++) {
-      result.push(lines[i]);
-    }
-    result.push(lines[endLine].slice(0, node.loc.end.column));
-    
-    return result.join('\n');
-  }
-
-  /**
-   * AST Traversal utility
-   */
-  traverseAST(node, visitor) {
-    if (!node || typeof node !== 'object') return;
-    
-    // Call appropriate visitor method
-    const nodeType = node.type;
-    if (visitor[`visit${nodeType}`]) {
-      const shouldContinue = visitor[`visit${nodeType}`](node);
-      if (!shouldContinue) return;
-    }
-    
-    // Generic visit method
-    if (visitor.visit) {
-      const shouldContinue = visitor.visit(node);
-      if (!shouldContinue) return;
-    }
-    
-    // Traverse children
-    for (const key in node) {
-      if (key === 'parent') continue; // Avoid cycles
-      
-      const child = node[key];
-      if (Array.isArray(child)) {
-        for (const item of child) {
-          if (item && typeof item === 'object') {
-            item.parent = node; // Add parent reference
-            this.traverseAST(item, visitor);
-          }
-        }
-      } else if (child && typeof child === 'object') {
-        child.parent = node; // Add parent reference
-        this.traverseAST(child, visitor);
-      }
-    }
-  }
-
-  getLanguageFromPath(filePath) {
-    const ext = filePath.split('.').pop().toLowerCase();
-    const languageMap = {
-      'js': 'javascript', 'jsx': 'javascript', 
-      'ts': 'typescript', 'tsx': 'typescript',
-      'mjs': 'javascript', 'cjs': 'javascript'
-    };
-    return languageMap[ext] || 'javascript';
-  }
-}
-
-module.exports = new C029DataFlowAnalyzer();