@sun-asterisk/sunlint 1.2.2 → 1.3.1

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

@@ -1,133 +0,0 @@
-/**
- * AST-based C029 Analyzer - Smart Pipeline Integration
- * 
- * This analyzer forwards to the Smart Pipeline for superior accuracy and performance
- * Maintains compatibility with the heuristic engine's AST expectations
- */
-
-class C029ASTAnalyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'AST-Enhanced Catch Block Error Logging (Smart Pipeline)';
-    this.description = 'Catch blocks must log errors - using Smart Pipeline 3-stage analysis';
-    
-    // Load Smart Pipeline
-    this.smartPipeline = null;
-    
-    try {
-      this.smartPipeline = require('./analyzer-smart-pipeline.js');
-      // Debug message will be shown by Smart Pipeline itself when verbose
-    } catch (error) {
-      console.warn('⚠️ C029 AST: Smart Pipeline failed:', error.message);
-      this.smartPipeline = null;
-    }
-  }
-
-  async analyze(files, language, options = {}) {
-    // Use Smart Pipeline if available
-    if (this.smartPipeline) {
-      if (options.verbose) {
-        console.log('🎯 C029 AST: Using Smart Pipeline (3-stage analysis)...');
-      }
-      return await this.smartPipeline.analyze(files, language, options);
-    } else {
-      if (options.verbose) {
-        console.log('🔍 C029 AST: Using fallback analysis...');
-      }
-      return await this.fallbackAnalysis(files, language, options);
-    }
-  }
-
-  async fallbackAnalysis(files, language, options = {}) {
-    const violations = [];
-    const fs = require('fs');
-    const path = require('path');
-    
-    if (options.verbose) {
-      console.log(`🔍 C029 AST: Processing ${files.length} files with fallback analysis...`);
-    }
-
-    for (const filePath of files) {
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, content, language);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`⚠️ C029 AST: Error processing ${filePath}:`, error.message);
-      }
-    }
-    
-    return violations;
-  }
-
-  async analyzeFile(filePath, content, language) {
-    const violations = [];
-    const lines = content.split('\n');
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      
-      // Simple catch block detection for fallback
-      if (line.includes('catch') && line.includes('(')) {
-        const catchBlock = this.extractCatchBlock(lines, i);
-        
-        if (this.isCatchBlockEmpty(catchBlock.content)) {
-          violations.push({
-            file: filePath,
-            line: i + 1,
-            column: line.indexOf('catch') + 1,
-            message: 'Empty catch block detected (fallback analysis)',
-            severity: 'error',
-            ruleId: this.ruleId,
-            type: 'empty_catch_fallback'
-          });
-        }
-      }
-    }
-    
-    return violations;
-  }
-
-  extractCatchBlock(lines, startIndex) {
-    const content = [];
-    let braceCount = 0;
-    let inBlock = false;
-    
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      content.push(line);
-      
-      for (const char of line) {
-        if (char === '{') {
-          braceCount++;
-          inBlock = true;
-        } else if (char === '}') {
-          braceCount--;
-          if (braceCount === 0 && inBlock) {
-            return { content, endIndex: i };
-          }
-        }
-      }
-    }
-    
-    return { content, endIndex: startIndex };
-  }
-
-  isCatchBlockEmpty(content) {
-    const blockContent = content.join('\n');
-    
-    // Remove comments and whitespace
-    const cleanContent = blockContent
-      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove multi-line comments
-      .replace(/\/\/.*$/gm, '') // Remove single-line comments
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .trim();
-    
-    // Check if only contains catch declaration and braces
-    const hasOnlyStructure = /^catch\s*\([^)]*\)\s*\{\s*\}$/.test(cleanContent);
-    
-    return hasOnlyStructure;
-  }
-}
-
-module.exports = C029ASTAnalyzer;

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

@@ -1,408 +0,0 @@
-/**
- * C029 Control Flow Graph Analyzer
- * 
- * Uses Control Flow Graph to understand execution paths and detect
- * unreachable error handling or dead error variables
- * 
- * Technology Showcase: Advanced static analysis beyond traditional linters
- */
-
-class C029ControlFlowAnalyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Control Flow Graph Enhanced Catch Analysis';
-    this.description = 'Uses CFG to detect unreachable error handling and dead variables';
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    console.log(`📊 C029 CFG: Analyzing ${files.length} files with Control Flow Graph...`);
-
-    for (const filePath of files) {
-      try {
-        const content = require('fs').readFileSync(filePath, 'utf8');
-        const ast = await this.parseAST(content, language, filePath);
-        
-        if (ast) {
-          // Build Control Flow Graph
-          const cfg = this.buildControlFlowGraph(ast);
-          
-          // Analyze catch blocks within CFG context
-          const cfgViolations = this.analyzeCatchBlocksInCFG(cfg, filePath, content);
-          violations.push(...cfgViolations);
-        }
-
-      } catch (error) {
-        console.warn(`C029 CFG skipping ${filePath}: ${error.message}`);
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * Build Control Flow Graph from AST
-   * Maps all possible execution paths through the code
-   */
-  buildControlFlowGraph(ast) {
-    const cfg = {
-      nodes: new Map(),     // CFG nodes (basic blocks)
-      edges: new Map(),     // CFG edges (control flow)
-      entryNode: null,      // Program entry point
-      exitNodes: new Set(), // Program exit points
-      catchBlocks: new Map() // Catch block metadata
-    };
-
-    let nodeId = 0;
-    
-    // Traverse AST and build CFG
-    const buildCFGVisitor = {
-      // Handle function declarations/expressions
-      visitFunction: (node) => {
-        const functionCFG = this.buildFunctionCFG(node, nodeId);
-        this.mergeCFG(cfg, functionCFG);
-        nodeId += functionCFG.nodeCount;
-        return true;
-      },
-      
-      // Handle try-catch statements
-      visitTryStatement: (node) => {
-        const tryCatchCFG = this.buildTryCatchCFG(node, nodeId);
-        this.mergeCFG(cfg, tryCatchCFG);
-        nodeId += tryCatchCFG.nodeCount;
-        return true;
-      }
-    };
-
-    this.traverseAST(ast, buildCFGVisitor);
-    return cfg;
-  }
-
-  /**
-   * Build CFG for try-catch-finally blocks
-   * Models exception flow and normal flow paths
-   */
-  buildTryCatchCFG(tryNode, startNodeId) {
-    const cfg = {
-      nodes: new Map(),
-      edges: new Map(),
-      nodeCount: 0,
-      catchBlocks: new Map()
-    };
-
-    let currentNodeId = startNodeId;
-
-    // Try block entry
-    const tryEntry = this.createCFGNode(currentNodeId++, 'try_entry', tryNode.block);
-    cfg.nodes.set(tryEntry.id, tryEntry);
-
-    // Try block execution paths
-    const tryExitNormal = this.createCFGNode(currentNodeId++, 'try_exit_normal');
-    const tryExitException = this.createCFGNode(currentNodeId++, 'try_exit_exception');
-
-    // Catch block(s)
-    const catchNodes = [];
-    if (tryNode.handler) {
-      const catchEntry = this.createCFGNode(currentNodeId++, 'catch_entry', tryNode.handler);
-      const catchExit = this.createCFGNode(currentNodeId++, 'catch_exit');
-      
-      catchNodes.push({ entry: catchEntry, exit: catchExit, handler: tryNode.handler });
-      cfg.nodes.set(catchEntry.id, catchEntry);
-      cfg.nodes.set(catchExit.id, catchExit);
-      
-      // Store catch block metadata for analysis
-      cfg.catchBlocks.set(catchEntry.id, {
-        handler: tryNode.handler,
-        errorParam: tryNode.handler.param,
-        body: tryNode.handler.body,
-        reachableFromTry: true // Will be computed later
-      });
-    }
-
-    // Finally block (if exists)
-    let finallyEntry = null, finallyExit = null;
-    if (tryNode.finalizer) {
-      finallyEntry = this.createCFGNode(currentNodeId++, 'finally_entry', tryNode.finalizer);
-      finallyExit = this.createCFGNode(currentNodeId++, 'finally_exit');
-      cfg.nodes.set(finallyEntry.id, finallyEntry);
-      cfg.nodes.set(finallyExit.id, finallyExit);
-    }
-
-    // Build control flow edges
-    this.addCFGEdge(cfg, tryEntry.id, tryExitNormal.id, 'normal_flow');
-    this.addCFGEdge(cfg, tryEntry.id, tryExitException.id, 'exception_flow');
-
-    // Exception flow to catch blocks
-    for (const catchNode of catchNodes) {
-      this.addCFGEdge(cfg, tryExitException.id, catchNode.entry.id, 'catch_flow');
-      this.addCFGEdge(cfg, catchNode.exit.id, finallyEntry?.id || 'exit', 'post_catch');
-    }
-
-    // Normal flow to finally or exit
-    this.addCFGEdge(cfg, tryExitNormal.id, finallyEntry?.id || 'exit', 'normal_completion');
-
-    cfg.nodeCount = currentNodeId - startNodeId;
-    return cfg;
-  }
-
-  /**
-   * Analyze catch blocks within CFG context
-   * Detects unreachable error handling and control flow issues
-   */
-  analyzeCatchBlocksInCFG(cfg, filePath, content) {
-    const violations = [];
-    const isTestFile = this.isTestFile(filePath);
-
-    for (const [nodeId, catchInfo] of cfg.catchBlocks) {
-      const analysis = this.analyzeCatchBlockCFG(nodeId, catchInfo, cfg, isTestFile);
-      
-      if (analysis.isViolation) {
-        violations.push({
-          ruleId: this.ruleId,
-          file: filePath,
-          line: catchInfo.handler.loc ? catchInfo.handler.loc.start.line : 1,
-          column: catchInfo.handler.loc ? catchInfo.handler.loc.start.column + 1 : 1,
-          message: analysis.message,
-          severity: analysis.severity,
-          code: this.getCodeFromNode(catchInfo.handler, content),
-          type: analysis.type,
-          confidence: analysis.confidence,
-          suggestion: analysis.suggestion,
-          cfgAnalysis: analysis.cfgData
-        });
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * CFG-based analysis of single catch block
-   */
-  analyzeCatchBlockCFG(nodeId, catchInfo, cfg, isTestFile) {
-    const errorParam = catchInfo.errorParam;
-    const catchBody = catchInfo.body;
-    
-    // 1. Check if catch block is reachable
-    const reachabilityAnalysis = this.analyzeCatchReachability(nodeId, cfg);
-    if (!reachabilityAnalysis.isReachable) {
-      return {
-        isViolation: true,
-        type: 'unreachable_catch',
-        message: 'Catch block is unreachable - dead code',
-        severity: 'warning',
-        confidence: 0.9,
-        suggestion: 'Remove unreachable catch block or fix control flow',
-        cfgData: reachabilityAnalysis
-      };
-    }
-
-    // 2. Check for control flow that bypasses error handling
-    const flowAnalysis = this.analyzeErrorHandlingFlow(nodeId, catchInfo, cfg);
-    if (flowAnalysis.hasBypassFlow) {
-      return {
-        isViolation: true,
-        type: 'bypassed_error_handling',
-        message: 'Control flow may bypass error handling',
-        severity: 'warning',
-        confidence: 0.8,
-        suggestion: 'Ensure all exception paths are properly handled',
-        cfgData: flowAnalysis
-      };
-    }
-
-    // 3. Check for error variable usage in control flow
-    if (errorParam) {
-      const variableFlowAnalysis = this.analyzeErrorVariableFlow(errorParam, catchInfo, cfg);
-      
-      if (!variableFlowAnalysis.isUsed) {
-        return {
-          isViolation: true,
-          type: 'unused_error_variable_cfg',
-          message: `Error variable '${errorParam.name}' is unused in all control flow paths`,
-          severity: 'error',
-          confidence: 0.95,
-          suggestion: 'Use error variable or rename to indicate intentional ignore',
-          cfgData: variableFlowAnalysis
-        };
-      }
-      
-      if (variableFlowAnalysis.hasDeadCode) {
-        return {
-          isViolation: true,
-          type: 'dead_error_code',
-          message: 'Error handling code contains unreachable statements',
-          severity: 'warning',
-          confidence: 0.85,
-          suggestion: 'Remove dead code or fix control flow logic',
-          cfgData: variableFlowAnalysis
-        };
-      }
-    }
-
-    // 4. Apply context-specific rules
-    if (isTestFile && this.hasTestAssertions(catchBody)) {
-      return { isViolation: false, reason: 'test_assertions_cfg' };
-    }
-
-    return { isViolation: false, reason: 'properly_handled_cfg' };
-  }
-
-  /**
-   * Analyze if catch block is reachable through any execution path
-   */
-  analyzeCatchReachability(catchNodeId, cfg) {
-    const reachable = new Set();
-    const visited = new Set();
-    
-    // DFS from entry points to find reachable nodes
-    const dfs = (nodeId) => {
-      if (visited.has(nodeId)) return;
-      visited.add(nodeId);
-      reachable.add(nodeId);
-      
-      const edges = cfg.edges.get(nodeId) || [];
-      for (const edge of edges) {
-        dfs(edge.to);
-      }
-    };
-
-    // Start from all entry points
-    if (cfg.entryNode) {
-      dfs(cfg.entryNode);
-    }
-
-    return {
-      isReachable: reachable.has(catchNodeId),
-      reachablePaths: this.findPathsTo(catchNodeId, cfg),
-      totalReachableNodes: reachable.size
-    };
-  }
-
-  /**
-   * Analyze error variable usage across control flow paths
-   */
-  analyzeErrorVariableFlow(errorParam, catchInfo, cfg) {
-    const variableName = errorParam.name;
-    const usageMap = new Map(); // nodeId -> usage info
-    
-    // Find all references to error variable in catch block
-    const references = this.findVariableReferences(variableName, catchInfo.body);
-    
-    // Analyze usage in context of control flow
-    let hasUsefulUsage = false;
-    let hasDeadCode = false;
-    
-    for (const ref of references) {
-      const usageType = this.categorizeErrorUsage(ref);
-      if (['logging', 'rethrowing', 'error_handling'].includes(usageType)) {
-        hasUsefulUsage = true;
-      }
-    }
-
-    return {
-      isUsed: references.length > 0,
-      hasUsefulUsage,
-      hasDeadCode,
-      references: references.length,
-      usageDistribution: this.getUsageDistribution(references)
-    };
-  }
-
-  // Utility methods (simplified versions)
-  createCFGNode(id, type, astNode = null) {
-    return {
-      id,
-      type,
-      astNode,
-      predecessors: new Set(),
-      successors: new Set()
-    };
-  }
-
-  addCFGEdge(cfg, fromId, toId, type) {
-    if (!cfg.edges.has(fromId)) {
-      cfg.edges.set(fromId, []);
-    }
-    cfg.edges.get(fromId).push({ to: toId, type });
-  }
-
-  mergeCFG(targetCFG, sourceCFG) {
-    // Merge nodes and edges from source to target
-    for (const [id, node] of sourceCFG.nodes) {
-      targetCFG.nodes.set(id, node);
-    }
-    for (const [id, edges] of sourceCFG.edges) {
-      targetCFG.edges.set(id, edges);
-    }
-    for (const [id, catchInfo] of sourceCFG.catchBlocks) {
-      targetCFG.catchBlocks.set(id, catchInfo);
-    }
-  }
-
-  findPathsTo(targetNodeId, cfg) {
-    // Simplified path finding implementation
-    return [];
-  }
-
-  findVariableReferences(variableName, astNode) {
-    // Reuse from previous implementation
-    return [];
-  }
-
-  categorizeErrorUsage(referenceNode) {
-    // Reuse from previous implementation
-    return 'unknown';
-  }
-
-  getUsageDistribution(references) {
-    return {
-      logging: 0,
-      rethrowing: 0,
-      trivial: 0,
-      other: references.length
-    };
-  }
-
-  hasTestAssertions(astNode) {
-    // Simplified test assertion check
-    return false;
-  }
-
-  isTestFile(filePath) {
-    const testPatterns = ['__tests__', '.test.', '.spec.', '/test/', '/tests/'];
-    return testPatterns.some(pattern => filePath.includes(pattern));
-  }
-
-  getCodeFromNode(node, content) {
-    // Simplified code extraction
-    return node.toString ? node.toString() : 'catch block';
-  }
-
-  async parseAST(content, language, filePath) {
-    // Reuse existing AST parsing logic
-    return null;
-  }
-
-  traverseAST(node, visitor) {
-    // Reuse existing AST traversal logic
-  }
-
-  analyzeErrorHandlingFlow(nodeId, catchInfo, cfg) {
-    return {
-      hasBypassFlow: false,
-      flowPaths: []
-    };
-  }
-
-  buildFunctionCFG(node, startNodeId) {
-    return {
-      nodes: new Map(),
-      edges: new Map(),
-      nodeCount: 1,
-      catchBlocks: new Map()
-    };
-  }
-}
-
-module.exports = new C029ControlFlowAnalyzer();