@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/rules/common/C029_catch_block_logging/analyzer.js

@@ -0,0 +1,129 @@
+/**
+ * C029 Analyzer - Smart Pipeline Integration
+ * 
+ * This analyzer forwards to the Smart Pipeline for superior accuracy and performance
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class C029Analyzer {
+  constructor() {
+    this.ruleId = 'C029';
+    this.ruleName = 'Enhanced Catch Block Error Logging';
+    this.description = 'Mọi catch block phải log nguyên nhân lỗi đầy đủ và bảo toàn context (Smart Pipeline 3-stage analysis)';
+    
+    // Load Smart Pipeline as primary analyzer
+    this.smartPipeline = null;
+    
+    try {
+      this.smartPipeline = require('./analyzer-smart-pipeline.js');
+      console.log('🎯 C029: Smart Pipeline loaded (3-stage: Regex → AST → Data Flow)');
+    } catch (error) {
+      console.warn('⚠️ C029: Smart Pipeline failed, using fallback:', error.message);
+      this.smartPipeline = null;
+    }
+  }
+
+  async analyze(files, language, options = {}) {
+    // Use Smart Pipeline as primary choice
+    if (this.smartPipeline) {
+      console.log('🎯 C029: Using Smart Pipeline (3-stage analysis)...');
+      return await this.smartPipeline.analyze(files, language, options);
+    } else {
+      console.log('🔍 C029: Using fallback regex analysis...');
+      return await this.analyzeWithRegex(files, language, options);
+    }
+  }
+
+  async analyzeWithRegex(files, language, options = {}) {
+    const violations = [];
+    
+    for (const filePath of files) {
+      if (options.verbose) {
+        console.log(`🔍 C029 Regex: Processing ${path.basename(filePath)}...`);
+      }
+      
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const fileViolations = await this.analyzeFile(filePath, content, language);
+        violations.push(...fileViolations);
+      } catch (error) {
+        console.warn(`⚠️ C029: 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
+      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',
+            severity: 'error',
+            ruleId: this.ruleId,
+            type: 'empty_catch'
+          });
+        }
+      }
+    }
+    
+    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 = C029Analyzer;

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

@@ -0,0 +1,441 @@
+/**
+ * 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

@@ -0,0 +1,127 @@
+/**
+ * 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;