@sun-asterisk/sunlint 1.2.2 → 1.3.1

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

@@ -1,110 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-class C029Analyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Enhanced Catch Block Error Logging';
-    this.description = 'Smart 3-stage pipeline: Regex → AST → Data Flow analysis';
-    
-    // Load smart pipeline analyzer
-    this.smartPipeline = null;
-    
-    try {
-      this.smartPipeline = require('./analyzer-smart-pipeline.js');
-      console.log('🎯 C029: Smart Pipeline loaded (Regex → AST → Data Flow)');
-    } catch (error) {
-      console.warn('⚠️ C029: Smart Pipeline failed, falling back to basic analysis:', error.message);
-    }
-  }
-
-  async analyze(files, language, options = {}) {
-    // Use smart pipeline for optimal performance and accuracy
-    if (this.smartPipeline) {
-      console.log('🎯 C029: Using Smart Pipeline (Regex → AST → Data Flow)...');
-      return await this.smartPipeline.analyze(files, language, options);
-    } else {
-      console.log('🔍 C029: Using basic regex analysis (fallback)...');
-      return await this.analyzeWithRegex(files, language, options);
-    }
-  }
-
-  async analyzeWithRegex(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`Analyzing ${path.basename(filePath)}...`);
-      }
-
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const lines = content.split('\n');
-
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i];
-          
-          // Basic catch block detection
-          if (/catch\s*\([^)]*\)\s*\{/.test(line)) {
-            const catchBlock = this.extractBasicCatchBlock(lines, i);
-            
-            if (this.isBasicViolation(catchBlock, filePath)) {
-              violations.push({
-                ruleId: this.ruleId,
-                file: filePath,
-                line: i + 1,
-                column: 1,
-                message: 'Catch block should log error information',
-                severity: 'error',
-                code: line.trim(),
-                suggestion: 'Add console.error() or appropriate logging'
-              });
-            }
-          }
-        }
-      } catch (error) {
-        console.warn(`Error analyzing ${filePath}:`, error.message);
-      }
-    }
-
-    return violations;
-  }
-
-  extractBasicCatchBlock(lines, startIndex) {
-    let braceCount = 0;
-    let content = '';
-    
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      content += line + '\n';
-      
-      braceCount += (line.match(/\{/g) || []).length;
-      braceCount -= (line.match(/\}/g) || []).length;
-      
-      if (braceCount === 0 && i > startIndex) {
-        break;
-      }
-    }
-    
-    return content.trim();
-  }
-
-  isBasicViolation(catchContent, filePath) {
-    // Skip test files
-    if (/(__tests__|\.test\.|\.spec\.|\/test\/|\/tests\/)/.test(filePath)) {
-      return false;
-    }
-    
-    // Empty catch block
-    if (!catchContent || catchContent.replace(/[{}\s]/g, '').length === 0) {
-      return true;
-    }
-    
-    // No logging patterns
-    const hasLogging = /console\.(log|error|warn|debug)|logger?\.(error|warn|info|debug)/.test(catchContent);
-    
-    return !hasLogging;
-  }
-}
-
-module.exports = new C029Analyzer();

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

@@ -1,441 +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');
-      console.log('🎯 C029 AST: Smart Pipeline loaded (Regex → AST → Data Flow)');
-    } 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) {
-      console.log('🎯 C029 AST: Using Smart Pipeline (3-stage analysis)...');
-      return await this.smartPipeline.analyze(files, language, options);
-    } else {
-      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');
-    
-    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 fileLanguage = this.getLanguageFromPath(filePath);
-          const ast = await this.parseAST(content, fileLanguage, filePath);
-          
-          if (ast) {
-            const astViolations = this.analyzeCatchBlocksWithAST(ast, catchBlocks, filePath, content);
-            violations.push(...astViolations);
-          } else {
-            // Fallback to regex if AST fails
-            const regexViolations = this.analyzeCatchBlocksWithRegex(catchBlocks, filePath, content);
-            violations.push(...regexViolations);
-          }
-
-        } catch (error) {
-          console.warn(`C029 AST skipping ${filePath}: ${error.message}`);
-        }
-      }
-      
-      // Give Node.js a chance to breathe between batches
-      if (i + batchSize < totalFiles) {
-        await new Promise(resolve => setImmediate(resolve));
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * Step 1: Fast regex-based catch block detection
-   */
-  findCatchBlocksWithRegex(content, filePath) {
-    const catchBlocks = [];
-    const lines = content.split('\n');
-    
-    lines.forEach((line, index) => {
-      const trimmedLine = line.trim();
-      if (this.isCatchBlockStart(trimmedLine)) {
-        // Extract catch block info using existing logic
-        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
-        catchBlocks.push({
-          startLine: index + 1,
-          content: catchBlockInfo.content,
-          parameter: this.extractCatchParameter(trimmedLine)
-        });
-      }
-    });
-    
-    return catchBlocks;
-  }
-
-  /**
-   * Step 2: AST-based analysis for precise content understanding
-   */
-  async parseAST(content, language, filePath) {
-    try {
-      if (!this.astRegistry || !this.astRegistry.parseCode) {
-        return null;
-      }
-      
-      return await this.astRegistry.parseCode(content, language, filePath);
-    } catch (error) {
-      // AST parsing failed, fall back to regex
-      return null;
-    }
-  }
-
-  analyzeCatchBlocksWithAST(ast, catchBlocks, filePath, content) {
-    const violations = [];
-    const isTestFile = this.isTestFile(filePath);
-    
-    for (const catchBlock of catchBlocks) {
-      const analysis = this.analyzeSingleCatchBlock(ast, catchBlock, filePath, content, isTestFile);
-      
-      if (analysis.isViolation) {
-        violations.push({
-          ruleId: this.ruleId,
-          file: filePath,
-          line: catchBlock.startLine,
-          column: 1,
-          message: analysis.message,
-          severity: analysis.severity,
-          code: catchBlock.content.split('\n')[0].trim(),
-          type: analysis.type,
-          confidence: analysis.confidence,
-          suggestion: analysis.suggestion
-        });
-      }
-    }
-    
-    return violations;
-  }
-
-  analyzeSingleCatchBlock(ast, catchBlock, filePath, content, isTestFile) {
-    const parameter = catchBlock.parameter;
-    const catchContent = catchBlock.content.toLowerCase();
-    const originalContent = catchBlock.content;
-    
-    // 1. Check for explicit ignore patterns
-    if (this.config.allowExplicitIgnore && this.isExplicitlyIgnored(parameter, catchContent)) {
-      return { isViolation: false, reason: 'explicitly_ignored' };
-    }
-    
-    // 2. Empty catch block - always violation
-    if (this.isCatchBlockEmpty(catchContent)) {
-      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'
-      };
-    }
-    
-    // 3. Test file context - allow test assertions
-    if (isTestFile && this.config.allowInTests && this.hasTestAssertions(catchContent, originalContent)) {
-      return { isViolation: false, reason: 'test_assertions' };
-    }
-    
-    // 4. Redux/async patterns - allow thunk error handling
-    if (this.config.allowReduxPatterns && this.hasReduxErrorHandling(catchContent, originalContent)) {
-      return { isViolation: false, reason: 'redux_patterns' };
-    }
-    
-    // 5. Check for logging or rethrowing
-    if (this.hasLoggingOrRethrow(catchContent, originalContent)) {
-      return { isViolation: false, reason: 'has_logging' };
-    }
-    
-    // 6. Silent catch block - violation
-    return {
-      isViolation: true,
-      type: 'silent_catch_block',
-      message: 'Catch block must log error or rethrow - silent error handling hides bugs',
-      severity: 'error',
-      confidence: 0.9,
-      suggestion: 'Add error logging (console.error, logger.error) or rethrow the error'
-    };
-  }
-
-  /**
-   * Language-specific explicit ignore patterns
-   */
-  isExplicitlyIgnored(parameter, content) {
-    // Java style: catch(Exception ignored)
-    if (parameter && parameter.includes('ignored')) {
-      return true;
-    }
-    
-    // Dart style: catch(_)
-    if (parameter && parameter.trim() === '_') {
-      return true;
-    }
-    
-    // Explicit ignore comments
-    const ignorePatterns = [
-      '// ignore',
-      '/* ignore',
-      '// todo',
-      '// intentionally',
-      '// suppress'
-    ];
-    
-    return ignorePatterns.some(pattern => content.includes(pattern));
-  }
-
-  /**
-   * Test file detection
-   */
-  isTestFile(filePath) {
-    const testPatterns = [
-      '__tests__',
-      '.test.',
-      '.spec.',
-      '/test/',
-      '/tests/',
-      'test-',
-      'spec-'
-    ];
-    
-    return testPatterns.some(pattern => filePath.includes(pattern));
-  }
-
-  /**
-   * Enhanced test assertion detection
-   */
-  hasTestAssertions(content, originalContent) {
-    const testPatterns = [
-      'expect(',
-      'assert(',
-      'should.',
-      'toequal(',
-      'tobecalled',
-      'tocontain',
-      'tohavebeencalled',
-      'tobe(',
-      'chai.',
-      'sinon.',
-      'jest.'
-    ];
-
-    return testPatterns.some(pattern => 
-      content.includes(pattern.toLowerCase()) || 
-      originalContent.toLowerCase().includes(pattern.toLowerCase())
-    );
-  }
-
-  /**
-   * Redux/async error handling patterns
-   */
-  hasReduxErrorHandling(content, originalContent) {
-    const reduxPatterns = [
-      'rejectwithvalue',
-      'dispatch(',
-      'handleaxioserror',
-      'seterror(',
-      'return value',
-      'thunk'
-    ];
-
-    return reduxPatterns.some(pattern => 
-      content.includes(pattern.toLowerCase()) || 
-      originalContent.toLowerCase().includes(pattern.toLowerCase())
-    );
-  }
-
-  /**
-   * Enhanced logging detection
-   */
-  hasLoggingOrRethrow(content, originalContent) {
-    // Throw statements
-    if (content.includes('throw ') || content.includes('throw;')) {
-      return true;
-    }
-
-    // Function calls with error parameter - likely error handlers
-    const errorHandlerPatterns = [
-      'handle',
-      'process',
-      'report',
-      'track',
-      'capture',
-      'send',
-      'notify'
-    ];
-    
-    // Check for function calls that take error as parameter
-    if (originalContent.match(/\w+\s*\(\s*error?\s*\)/i)) {
-      return true;
-    }
-    
-    // Check for error handler function calls
-    if (errorHandlerPatterns.some(pattern => 
-      originalContent.toLowerCase().includes(pattern + 'error') ||
-      originalContent.toLowerCase().includes(pattern + '(error') ||
-      originalContent.toLowerCase().includes(pattern + '(err')
-    )) {
-      return true;
-    }
-
-    // Logging patterns
-    const loggingPatterns = [
-      'console.error',
-      'console.log',
-      'console.warn',
-      'logger.error',
-      'log.error',
-      'logger.warn',
-      'winston.error',
-      'bunyan.error',
-      'pino.error',
-      '.error(',
-      '.warn(',
-      '.log(',
-      'handleerror',
-      'logerror'
-    ];
-
-    return loggingPatterns.some(pattern => 
-      content.includes(pattern) || originalContent.includes(pattern)
-    );
-  }
-
-  // Utility methods (reuse existing logic)
-  isCatchBlockStart(line) {
-    return line.includes('catch (') || line.includes('catch(');
-  }
-
-  extractCatchParameter(line) {
-    const match = line.match(/catch\s*\(\s*([^)]+)\s*\)/);
-    return match ? match[1].trim() : null;
-  }
-
-  extractCatchBlockInfo(lines, startIndex) {
-    const catchBlockLines = [];
-    let braceDepth = 0;
-    let foundCatchBrace = false;
-
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      catchBlockLines.push(line);
-      
-      if (this.isCatchBlockStart(line.trim())) {
-        for (const char of line) {
-          if (char === '{') {
-            foundCatchBrace = true;
-            braceDepth = 1;
-          }
-        }
-      } else if (foundCatchBrace) {
-        for (const char of line) {
-          if (char === '{') braceDepth++;
-          else if (char === '}') braceDepth--;
-        }
-        
-        if (braceDepth === 0) break;
-      }
-    }
-
-    return {
-      content: catchBlockLines.join('\n')
-    };
-  }
-
-  isCatchBlockEmpty(content) {
-    const cleanedContent = content
-      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
-      .replace(/\/\/.*$/gm, '') // Remove line comments
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .trim();
-    
-    // Check if only braces remain
-    const bodyMatch = cleanedContent.match(/\{(.*)\}/s);
-    return !bodyMatch || bodyMatch[1].trim().length === 0;
-  }
-
-  getLanguageFromPath(filePath) {
-    const ext = filePath.split('.').pop().toLowerCase();
-    
-    const languageMap = {
-      'js': 'javascript',
-      'jsx': 'javascript', 
-      'ts': 'typescript',
-      'tsx': 'typescript',
-      'mjs': 'javascript',
-      'cjs': 'javascript',
-      'dart': 'dart',
-      'java': 'java',
-      'kt': 'kotlin'
-    };
-    
-    return languageMap[ext] || 'javascript';
-  }
-
-  /**
-   * Fallback regex analysis if AST fails
-   */
-  analyzeCatchBlocksWithRegex(catchBlocks, filePath, content) {
-    const violations = [];
-    const isTestFile = this.isTestFile(filePath);
-    
-    for (const catchBlock of catchBlocks) {
-      const analysis = this.analyzeSingleCatchBlock(null, catchBlock, filePath, content, isTestFile);
-      
-      if (analysis.isViolation) {
-        violations.push({
-          ruleId: this.ruleId,
-          file: filePath,
-          line: catchBlock.startLine,
-          column: 1,
-          message: analysis.message,
-          severity: analysis.severity,
-          code: catchBlock.content.split('\n')[0].trim(),
-          type: analysis.type,
-          confidence: analysis.confidence * 0.8, // Lower confidence for regex fallback
-          suggestion: analysis.suggestion
-        });
-      }
-    }
-    
-    return violations;
-  }
-}
-
-module.exports = new C029ASTAnalyzer();

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

@@ -1,127 +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');
-      console.log('🎯 C029 AST: Smart Pipeline loaded (Regex → AST → Data Flow)');
-    } 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) {
-      console.log('🎯 C029 AST: Using Smart Pipeline (3-stage analysis)...');
-      return await this.smartPipeline.analyze(files, language, options);
-    } else {
-      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');
-    
-    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;