@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/rules/common/C029_catch_block_logging/analyzer-multi-tech.js

@@ -0,0 +1,487 @@
+/**
+ * C029 Catch Block Logging Analyzer
+ * 
+ * Enhanced multi-technology analyzer combining:
+ * - Regex pattern matching (basic detection)
+ * - AST-based analysis (structural understanding)
+ * - Data flow analysis (variable tracking)
+ * - Control flow analysis (execution path understanding)
+ * - Semantic analysis (intent understanding)
+ * - Pattern learning (adaptive rules)
+ * - Multi-language support (cross-language compatibility)
+ * 
+ * Technology Showcase: Demonstrates SunLint's advanced analysis capabilities
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class C029CatchBlockAnalyzer {
+  constructor() {
+    this.ruleId = 'C029';
+    this.ruleName = 'Advanced Catch Block Logging';
+    this.description = 'Multi-technology analysis for catch block error handling';
+    
+    // Load analyzers with graceful fallback
+    this.analyzers = this.loadAnalyzers();
+    
+    // Technology orchestration configuration
+    this.analysisConfig = {
+      enableRegex: true,
+      enableAST: true,
+      enableDataflow: true,
+      enableControlflow: true,
+      enableSemantic: true,
+      enablePatternLearning: true,
+      enableMultiLanguage: true,
+      confidenceThreshold: 0.5,
+      combinationStrategy: 'weighted_voting'  // Options: 'union', 'intersection', 'weighted_voting'
+    };
+    
+    // Technology weights for voting
+    this.technologyWeights = {
+      regex: 0.15,
+      ast: 0.25,
+      dataflow: 0.20,
+      controlflow: 0.15,
+      semantic: 0.15,
+      patternLearning: 0.10
+    };
+    
+    // Performance tracking
+    this.performanceMetrics = {
+      technologyExecutionTimes: new Map(),
+      accuracyComparisons: new Map(),
+      combinationEffectiveness: new Map()
+    };
+  }
+
+  /**
+   * Load all available analyzers with graceful fallback
+   */
+  loadAnalyzers() {
+    const analyzers = {};
+    
+    const analyzerConfigs = [
+      { name: 'ast', path: './ast-analyzer.js', description: 'AST-based analysis' },
+      { name: 'dataflow', path: './dataflow-analyzer.js', description: 'Data flow analysis' },
+      { name: 'cfg', path: './cfg-analyzer.js', description: 'Control flow analysis' },
+      { name: 'semantic', path: './semantic-analyzer.js', description: 'Semantic analysis' },
+      { name: 'patternLearning', path: './pattern-learning-analyzer.js', description: 'Pattern learning' },
+      { name: 'multiLanguage', path: './multi-language-ast-engine.js', description: 'Multi-language support' }
+    ];
+    
+    for (const config of analyzerConfigs) {
+      try {
+        analyzers[config.name] = require(config.path);
+        console.log(`✅ C029: ${config.description} loaded`);
+      } catch (error) {
+        console.warn(`⚠️ C029: ${config.description} not available:`, error.message);
+        analyzers[config.name] = null;
+      }
+    }
+    
+    return analyzers;
+  }
+
+  async analyze(files, language, options = {}) {
+    console.log(`🔬 C029 Multi-Technology Analysis: Processing ${files.length} files with advanced techniques...`);
+    
+    const startTime = Date.now();
+    const allResults = new Map(); // technology -> violations
+    const executionTimes = new Map();
+    
+    // Run all available technologies in parallel
+    const analysisPromises = [];
+    
+    // 1. Regex Analysis (always available)
+    if (this.analysisConfig.enableRegex) {
+      analysisPromises.push(
+        this.runTechnologyAnalysis('regex', () => this.analyzeWithRegex(files, language, options))
+      );
+    }
+    
+    // 2. AST Analysis
+    if (this.analysisConfig.enableAST && this.analyzers.ast) {
+      analysisPromises.push(
+        this.runTechnologyAnalysis('ast', () => this.analyzers.ast.analyze(files, language, options))
+      );
+    }
+    
+    // 3. Data Flow Analysis
+    if (this.analysisConfig.enableDataflow && this.analyzers.dataflow) {
+      analysisPromises.push(
+        this.runTechnologyAnalysis('dataflow', () => this.analyzers.dataflow.analyze(files, language, options))
+      );
+    }
+    
+    // 4. Control Flow Analysis
+    if (this.analysisConfig.enableControlflow && this.analyzers.cfg) {
+      analysisPromises.push(
+        this.runTechnologyAnalysis('controlflow', () => this.analyzers.cfg.analyze(files, language, options))
+      );
+    }
+    
+    // 5. Semantic Analysis
+    if (this.analysisConfig.enableSemantic && this.analyzers.semantic) {
+      analysisPromises.push(
+        this.runTechnologyAnalysis('semantic', () => this.analyzers.semantic.analyze(files, language, options))
+      );
+    }
+    
+    // 6. Pattern Learning Analysis
+    if (this.analysisConfig.enablePatternLearning && this.analyzers.patternLearning) {
+      analysisPromises.push(
+        this.runTechnologyAnalysis('patternLearning', () => this.analyzers.patternLearning.analyze(files, language, options))
+      );
+    }
+    
+    // 7. Multi-Language Analysis
+    if (this.analysisConfig.enableMultiLanguage && this.analyzers.multiLanguage) {
+      analysisPromises.push(
+        this.runTechnologyAnalysis('multiLanguage', () => this.analyzers.multiLanguage.analyze(files, language, options))
+      );
+    }
+    
+    // Wait for all analyses to complete
+    const results = await Promise.allSettled(analysisPromises);
+    
+    // Process results
+    for (const result of results) {
+      if (result.status === 'fulfilled') {
+        const { technology, violations, executionTime } = result.value;
+        allResults.set(technology, violations);
+        executionTimes.set(technology, executionTime);
+        console.log(`✅ ${technology}: ${violations.length} issues found (${executionTime}ms)`);
+      } else {
+        console.error(`❌ Analysis failed:`, result.reason);
+      }
+    }
+    
+    // Combine results using configured strategy
+    const finalViolations = this.combineResults(allResults, executionTimes);
+    
+    const totalTime = Date.now() - startTime;
+    console.log(`🎯 C029 Final Results: ${finalViolations.length} issues identified (${totalTime}ms total)`);
+    
+    // Update performance metrics
+    this.updatePerformanceMetrics(allResults, executionTimes, totalTime);
+    
+    return finalViolations;
+  }
+
+  /**
+   * Run a technology analysis with timing and error handling
+   */
+  async runTechnologyAnalysis(technology, analysisFunction) {
+    const startTime = Date.now();
+    
+    try {
+      const violations = await analysisFunction();
+      const executionTime = Date.now() - startTime;
+      
+      return {
+        technology,
+        violations: violations || [],
+        executionTime,
+        success: true
+      };
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      console.error(`❌ ${technology} analysis failed:`, error.message);
+      
+      return {
+        technology,
+        violations: [],
+        executionTime,
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Combine results from multiple technologies
+   */
+  combineResults(allResults, executionTimes) {
+    switch (this.analysisConfig.combinationStrategy) {
+      case 'union':
+        return this.combineUnion(allResults);
+      
+      case 'intersection':
+        return this.combineIntersection(allResults);
+      
+      case 'weighted_voting':
+      default:
+        return this.combineWeightedVoting(allResults);
+    }
+  }
+
+  /**
+   * Union strategy: Include all violations from all technologies
+   */
+  combineUnion(allResults) {
+    const allViolations = [];
+    const seenViolations = new Set();
+    
+    for (const [technology, violations] of allResults) {
+      for (const violation of violations) {
+        const key = `${violation.file}:${violation.line}:${violation.type}`;
+        
+        if (!seenViolations.has(key)) {
+          seenViolations.add(key);
+          allViolations.push({
+            ...violation,
+            detectedBy: [technology],
+            combinationStrategy: 'union'
+          });
+        } else {
+          // Find existing violation and add technology
+          const existing = allViolations.find(v => 
+            v.file === violation.file && 
+            v.line === violation.line && 
+            v.type === violation.type
+          );
+          if (existing) {
+            existing.detectedBy.push(technology);
+          }
+        }
+      }
+    }
+    
+    return allViolations;
+  }
+
+  /**
+   * Intersection strategy: Only include violations found by multiple technologies
+   */
+  combineIntersection(allResults) {
+    const violationCounts = new Map();
+    const violationData = new Map();
+    
+    // Count how many technologies detected each violation
+    for (const [technology, violations] of allResults) {
+      for (const violation of violations) {
+        const key = `${violation.file}:${violation.line}:${violation.type}`;
+        
+        violationCounts.set(key, (violationCounts.get(key) || 0) + 1);
+        
+        if (!violationData.has(key)) {
+          violationData.set(key, {
+            ...violation,
+            detectedBy: [technology],
+            combinationStrategy: 'intersection'
+          });
+        } else {
+          violationData.get(key).detectedBy.push(technology);
+        }
+      }
+    }
+    
+    // Only return violations detected by at least 2 technologies
+    const minDetections = Math.max(2, Math.floor(allResults.size / 2));
+    return Array.from(violationData.values())
+      .filter(violation => violationCounts.get(`${violation.file}:${violation.line}:${violation.type}`) >= minDetections);
+  }
+
+  /**
+   * Weighted voting strategy: Use confidence scores and technology weights
+   */
+  combineWeightedVoting(allResults) {
+    const violationScores = new Map();
+    const violationData = new Map();
+    
+    // Calculate weighted scores for each violation
+    for (const [technology, violations] of allResults) {
+      const weight = this.technologyWeights[technology] || 0.1;
+      
+      for (const violation of violations) {
+        const key = `${violation.file}:${violation.line}:${violation.type}`;
+        const score = (violation.confidence || 0.7) * weight;
+        
+        violationScores.set(key, (violationScores.get(key) || 0) + score);
+        
+        if (!violationData.has(key)) {
+          violationData.set(key, {
+            ...violation,
+            detectedBy: [technology],
+            weightedScore: score,
+            combinationStrategy: 'weighted_voting'
+          });
+        } else {
+          const existing = violationData.get(key);
+          existing.detectedBy.push(technology);
+          existing.weightedScore = violationScores.get(key);
+          
+          // Use highest confidence message
+          if ((violation.confidence || 0.7) > (existing.confidence || 0.7)) {
+            existing.message = violation.message;
+            existing.suggestion = violation.suggestion;
+          }
+        }
+      }
+    }
+    
+    // Return violations above confidence threshold
+    return Array.from(violationData.values())
+      .filter(violation => violation.weightedScore >= this.analysisConfig.confidenceThreshold)
+      .sort((a, b) => b.weightedScore - a.weightedScore);
+  }
+
+  /**
+   * Regex-based analysis (fallback)
+   */
+  async analyzeWithRegex(files, language, options = {}) {
+    const violations = [];
+    console.log(`📄 C029 Regex: Analyzing ${files.length} files with pattern matching...`);
+    
+    for (const filePath of files) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const regexViolations = this.findCatchBlocksRegex(content, filePath);
+        violations.push(...regexViolations);
+      } catch (error) {
+        console.warn(`C029 Regex skipping ${filePath}: ${error.message}`);
+      }
+    }
+    
+    return violations;
+  }
+
+  /**
+   * Find catch blocks using regex patterns
+   */
+  findCatchBlocksRegex(content, filePath) {
+    const violations = [];
+    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.extractCatchBlock(lines, i);
+        
+        if (this.isCatchBlockViolation(catchBlock, filePath)) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: i + 1,
+            column: 1,
+            message: 'Empty or inadequate error handling in catch block',
+            severity: 'error',
+            code: catchBlock.code,
+            type: 'regex_catch_violation',
+            confidence: 0.6,
+            suggestion: 'Add error logging or appropriate error handling',
+            detectedBy: ['regex']
+          });
+        }
+      }
+    }
+    
+    return violations;
+  }
+
+  /**
+   * Extract catch block content
+   */
+  extractCatchBlock(lines, startIndex) {
+    let braceCount = 0;
+    let content = '';
+    let endIndex = startIndex;
+    
+    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) {
+        endIndex = i;
+        break;
+      }
+    }
+    
+    return {
+      code: content.trim(),
+      startLine: startIndex + 1,
+      endLine: endIndex + 1,
+      content: content.trim()
+    };
+  }
+
+  /**
+   * Check if catch block is a violation
+   */
+  isCatchBlockViolation(catchBlock, filePath) {
+    const content = catchBlock.content;
+    
+    // Empty catch block
+    if (!content || content.replace(/[{}\s]/g, '').length === 0) {
+      return true;
+    }
+    
+    // Check for logging patterns
+    const hasLogging = /console\.(log|error|warn|debug)|logger?\.(error|warn|info|debug)|print/.test(content);
+    
+    // Skip test files (less strict)
+    const isTestFile = /(__tests__|\.test\.|\.spec\.|\/test\/|\/tests\/)/.test(filePath);
+    
+    return !hasLogging && !isTestFile;
+  }
+
+  /**
+   * Update performance metrics for analysis
+   */
+  updatePerformanceMetrics(allResults, executionTimes, totalTime) {
+    // Track execution times
+    for (const [technology, time] of executionTimes) {
+      if (!this.performanceMetrics.technologyExecutionTimes.has(technology)) {
+        this.performanceMetrics.technologyExecutionTimes.set(technology, []);
+      }
+      this.performanceMetrics.technologyExecutionTimes.get(technology).push(time);
+    }
+    
+    // Track accuracy comparisons (simplified)
+    const technologiesUsed = Array.from(allResults.keys());
+    for (let i = 0; i < technologiesUsed.length; i++) {
+      for (let j = i + 1; j < technologiesUsed.length; j++) {
+        const tech1 = technologiesUsed[i];
+        const tech2 = technologiesUsed[j];
+        const pair = `${tech1}-${tech2}`;
+        
+        const violations1 = allResults.get(tech1).length;
+        const violations2 = allResults.get(tech2).length;
+        const agreement = Math.abs(violations1 - violations2) / Math.max(violations1, violations2, 1);
+        
+        if (!this.performanceMetrics.accuracyComparisons.has(pair)) {
+          this.performanceMetrics.accuracyComparisons.set(pair, []);
+        }
+        this.performanceMetrics.accuracyComparisons.get(pair).push(agreement);
+      }
+    }
+  }
+
+  /**
+   * Get performance insights
+   */
+  getPerformanceInsights() {
+    const insights = {
+      averageExecutionTimes: new Map(),
+      technologiesUsed: Array.from(this.performanceMetrics.technologyExecutionTimes.keys()),
+      totalAnalysesRun: 0
+    };
+    
+    for (const [technology, times] of this.performanceMetrics.technologyExecutionTimes) {
+      const avg = times.reduce((sum, time) => sum + time, 0) / times.length;
+      insights.averageExecutionTimes.set(technology, avg);
+      insights.totalAnalysesRun += times.length;
+    }
+    
+    return insights;
+  }
+}
+
+module.exports = new C029CatchBlockAnalyzer();

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

@@ -0,0 +1,110 @@
+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();