@sun-asterisk/sunlint 1.2.2 → 1.3.1

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

@@ -1,459 +0,0 @@
-/**
- * C029 Semantic Analyzer
- * 
- * Uses semantic analysis to understand the meaning and intent of error handling code
- * Goes beyond syntax to understand developer intent and code semantics
- * 
- * Technology Showcase: Understanding code intent, not just structure
- */
-
-class C029SemanticAnalyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Semantic Intent-Based Catch Analysis';
-    this.description = 'Understands developer intent in error handling through semantic analysis';
-    
-    // Semantic patterns for different error handling intents
-    this.semanticPatterns = {
-      // Intent: Ignore errors intentionally
-      intentionalIgnore: [
-        /catch\s*\(\s*[_][\w]*\s*\)/,  // catch(_), catch(_ignored)
-        /\/\/\s*(ignore|suppress|intentional)/i,
-        /\/\*\s*(ignore|suppress|intentional)/i,
-        /catch\s*\([^)]*ignored[^)]*\)/i
-      ],
-      
-      // Intent: Log and continue
-      logAndContinue: [
-        /console\.(log|error|warn)/,
-        /logger\.(log|error|warn)/,
-        /log\.(error|warn|info)/
-      ],
-      
-      // Intent: Transform and rethrow
-      transformAndRethrow: [
-        /throw\s+new\s+\w+Error/,
-        /throw\s+.*Error\(/,
-        /rethrow/i
-      ],
-      
-      // Intent: Handle gracefully
-      gracefulHandling: [
-        /return\s+.*default/i,
-        /return\s+.*fallback/i,
-        /return\s+null/,
-        /return\s+undefined/,
-        /return\s+\[\]/,
-        /return\s+\{\}/
-      ],
-      
-      // Intent: Notify external systems
-      externalNotification: [
-        /notify/i,
-        /alert/i,
-        /report/i,
-        /track/i,
-        /analytics/i,
-        /monitoring/i,
-        /sentry/i,
-        /bugsnag/i
-      ],
-      
-      // Intent: Test verification
-      testVerification: [
-        /expect\(/,
-        /assert\(/,
-        /should\./,
-        /toBe\(/,
-        /toEqual\(/,
-        /toThrow\(/
-      ],
-      
-      // Intent: State management
-      stateManagement: [
-        /setState/,
-        /dispatch/,
-        /commit/,
-        /rejectWithValue/,
-        /setError/,
-        /setLoading/
-      ]
-    };
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    console.log(`🧠 C029 Semantic: Analyzing ${files.length} files with semantic understanding...`);
-
-    for (const filePath of files) {
-      try {
-        const content = require('fs').readFileSync(filePath, 'utf8');
-        const semanticViolations = await this.analyzeSemanticIntent(content, filePath, language);
-        violations.push(...semanticViolations);
-
-      } catch (error) {
-        console.warn(`C029 Semantic skipping ${filePath}: ${error.message}`);
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * Analyze semantic intent of error handling
-   */
-  async analyzeSemanticIntent(content, filePath, language) {
-    const violations = [];
-    const isTestFile = this.isTestFile(filePath);
-    
-    // Find all catch blocks with context
-    const catchBlocks = this.extractCatchBlocksWithContext(content);
-    
-    for (const catchBlock of catchBlocks) {
-      const semanticAnalysis = this.analyzeBlockSemantic(catchBlock, isTestFile, content);
-      
-      if (semanticAnalysis.isViolation) {
-        violations.push({
-          ruleId: this.ruleId,
-          file: filePath,
-          line: catchBlock.lineNumber,
-          column: 1,
-          message: semanticAnalysis.message,
-          severity: semanticAnalysis.severity,
-          code: catchBlock.code,
-          type: semanticAnalysis.type,
-          confidence: semanticAnalysis.confidence,
-          suggestion: semanticAnalysis.suggestion,
-          semanticIntent: semanticAnalysis.intent,
-          contextAnalysis: semanticAnalysis.context
-        });
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * Extract catch blocks with surrounding context for semantic analysis
-   */
-  extractCatchBlocksWithContext(content) {
-    const catchBlocks = [];
-    const lines = content.split('\n');
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      
-      if (this.isCatchBlockStart(line)) {
-        const catchBlock = this.extractFullCatchBlock(lines, i);
-        
-        // Add surrounding context for semantic analysis
-        const context = this.extractSurroundingContext(lines, i, catchBlock.endLine);
-        
-        catchBlocks.push({
-          ...catchBlock,
-          lineNumber: i + 1,
-          context
-        });
-      }
-    }
-    
-    return catchBlocks;
-  }
-
-  /**
-   * Analyze semantic intent of a catch block
-   */
-  analyzeBlockSemantic(catchBlock, isTestFile, fullContent) {
-    const blockContent = catchBlock.content;
-    const blockCode = catchBlock.code;
-    const context = catchBlock.context;
-    
-    // 1. Detect semantic intent
-    const intent = this.detectSemanticIntent(blockContent, context, isTestFile);
-    
-    // 2. Validate intent appropriateness
-    const validation = this.validateSemanticIntent(intent, catchBlock, isTestFile, fullContent);
-    
-    if (validation.isValid) {
-      return { isViolation: false, intent, context: validation };
-    }
-    
-    // 3. Generate semantic-aware violation
-    return {
-      isViolation: true,
-      type: validation.violationType,
-      message: validation.message,
-      severity: validation.severity,
-      confidence: validation.confidence,
-      suggestion: validation.suggestion,
-      intent,
-      context: validation
-    };
-  }
-
-  /**
-   * Detect the semantic intent of error handling
-   */
-  detectSemanticIntent(blockContent, context, isTestFile) {
-    const intents = [];
-    
-    // Check each semantic pattern category
-    for (const [intentType, patterns] of Object.entries(this.semanticPatterns)) {
-      for (const pattern of patterns) {
-        if (pattern.test(blockContent) || pattern.test(context.before) || pattern.test(context.after)) {
-          intents.push({
-            type: intentType,
-            confidence: this.calculateIntentConfidence(intentType, blockContent, context, isTestFile)
-          });
-        }
-      }
-    }
-    
-    // Handle empty catch blocks
-    if (this.isEmpty(blockContent)) {
-      intents.push({
-        type: 'silentIgnore',
-        confidence: 0.95
-      });
-    }
-    
-    // Handle unknown intent
-    if (intents.length === 0) {
-      intents.push({
-        type: 'unknown',
-        confidence: 0.1
-      });
-    }
-    
-    // Return primary intent (highest confidence)
-    return intents.sort((a, b) => b.confidence - a.confidence)[0];
-  }
-
-  /**
-   * Validate if the detected intent is appropriate for the context
-   */
-  validateSemanticIntent(intent, catchBlock, isTestFile, fullContent) {
-    const intentType = intent.type;
-    const confidence = intent.confidence;
-    
-    switch (intentType) {
-      case 'intentionalIgnore':
-        return this.validateIntentionalIgnore(catchBlock, confidence);
-        
-      case 'logAndContinue':
-        return this.validateLogAndContinue(catchBlock, confidence);
-        
-      case 'transformAndRethrow':
-        return this.validateTransformAndRethrow(catchBlock, confidence);
-        
-      case 'gracefulHandling':
-        return this.validateGracefulHandling(catchBlock, confidence);
-        
-      case 'externalNotification':
-        return this.validateExternalNotification(catchBlock, confidence);
-        
-      case 'testVerification':
-        return this.validateTestVerification(catchBlock, isTestFile, confidence);
-        
-      case 'stateManagement':
-        return this.validateStateManagement(catchBlock, confidence);
-        
-      case 'silentIgnore':
-        return this.validateSilentIgnore(catchBlock, isTestFile, confidence);
-        
-      default:
-        return this.validateUnknownIntent(catchBlock, confidence);
-    }
-  }
-
-  /**
-   * Validate intentional ignore patterns
-   */
-  validateIntentionalIgnore(catchBlock, confidence) {
-    // Intentional ignore is usually acceptable if properly documented
-    const hasDocumentation = this.hasProperDocumentation(catchBlock);
-    
-    if (hasDocumentation) {
-      return { isValid: true, reason: 'documented_ignore' };
-    }
-    
-    return {
-      isValid: false,
-      violationType: 'undocumented_ignore',
-      message: 'Intentional error ignore should be documented with reason',
-      severity: 'warning',
-      confidence: confidence * 0.8,
-      suggestion: 'Add comment explaining why error is intentionally ignored'
-    };
-  }
-
-  /**
-   * Validate log and continue patterns
-   */
-  validateLogAndContinue(catchBlock, confidence) {
-    // Check if logging actually includes error information
-    const hasErrorInfo = this.loggingIncludesErrorInfo(catchBlock);
-    
-    if (hasErrorInfo) {
-      return { isValid: true, reason: 'proper_logging' };
-    }
-    
-    return {
-      isValid: false,
-      violationType: 'incomplete_logging',
-      message: 'Error logging should include error details (message, stack, context)',
-      severity: 'warning',
-      confidence: confidence * 0.9,
-      suggestion: 'Include error.message, error.stack, or relevant error properties in logging'
-    };
-  }
-
-  /**
-   * Validate silent ignore (empty catch)
-   */
-  validateSilentIgnore(catchBlock, isTestFile, confidence) {
-    // Silent ignore is usually problematic except in specific contexts
-    if (isTestFile && this.isExpectedErrorInTest(catchBlock)) {
-      return { isValid: true, reason: 'expected_test_error' };
-    }
-    
-    return {
-      isValid: false,
-      violationType: 'silent_error_suppression',
-      message: 'Silent error suppression hides bugs and makes debugging difficult',
-      severity: 'error',
-      confidence: confidence,
-      suggestion: 'Add error logging, rethrowing, or explicit ignore with documentation'
-    };
-  }
-
-  /**
-   * Calculate confidence score for intent detection
-   */
-  calculateIntentConfidence(intentType, blockContent, context, isTestFile) {
-    let confidence = 0.5; // Base confidence
-    
-    // Adjust based on pattern strength
-    const patternCount = this.countMatchingPatterns(intentType, blockContent);
-    confidence += Math.min(patternCount * 0.2, 0.4);
-    
-    // Adjust based on context
-    if (isTestFile && intentType === 'testVerification') {
-      confidence += 0.3;
-    }
-    
-    // Adjust based on code quality indicators
-    if (this.hasGoodNaming(blockContent)) {
-      confidence += 0.1;
-    }
-    
-    if (this.hasDocumentation(context)) {
-      confidence += 0.1;
-    }
-    
-    return Math.min(confidence, 1.0);
-  }
-
-  // Helper methods (simplified implementations)
-  
-  isCatchBlockStart(line) {
-    return line.trim().includes('catch (') || line.trim().includes('catch(');
-  }
-
-  extractFullCatchBlock(lines, startIndex) {
-    // Simplified catch block extraction
-    return {
-      content: 'catch block content',
-      code: lines[startIndex],
-      endLine: startIndex + 5
-    };
-  }
-
-  extractSurroundingContext(lines, startLine, endLine) {
-    const before = lines.slice(Math.max(0, startLine - 3), startLine).join('\n');
-    const after = lines.slice(endLine + 1, Math.min(lines.length, endLine + 4)).join('\n');
-    
-    return { before, after };
-  }
-
-  isEmpty(content) {
-    return content.trim().replace(/[{}]/g, '').trim().length === 0;
-  }
-
-  hasProperDocumentation(catchBlock) {
-    const content = catchBlock.content + (catchBlock.context?.before || '');
-    return /\/\/|\/\*/.test(content);
-  }
-
-  loggingIncludesErrorInfo(catchBlock) {
-    const content = catchBlock.content;
-    return /error\.(message|stack|name)/.test(content) || /\$\{error\}/.test(content);
-  }
-
-  isExpectedErrorInTest(catchBlock) {
-    const context = catchBlock.context || {};
-    return /expect.*toThrow|assertThrows|shouldThrow/.test(context.before + context.after);
-  }
-
-  countMatchingPatterns(intentType, content) {
-    const patterns = this.semanticPatterns[intentType] || [];
-    return patterns.filter(pattern => pattern.test(content)).length;
-  }
-
-  hasGoodNaming(content) {
-    return /\b(error|err|exception|ex)\b/.test(content);
-  }
-
-  hasDocumentation(context) {
-    return /\/\/|\/\*/.test((context?.before || '') + (context?.after || ''));
-  }
-
-  isTestFile(filePath) {
-    const testPatterns = ['__tests__', '.test.', '.spec.', '/test/', '/tests/'];
-    return testPatterns.some(pattern => filePath.includes(pattern));
-  }
-
-  // Placeholder validation methods
-  validateTransformAndRethrow(catchBlock, confidence) {
-    return { isValid: true, reason: 'proper_transform' };
-  }
-
-  validateGracefulHandling(catchBlock, confidence) {
-    return { isValid: true, reason: 'graceful_handling' };
-  }
-
-  validateExternalNotification(catchBlock, confidence) {
-    return { isValid: true, reason: 'external_notification' };
-  }
-
-  validateTestVerification(catchBlock, isTestFile, confidence) {
-    if (!isTestFile) {
-      return {
-        isValid: false,
-        violationType: 'test_code_in_production',
-        message: 'Test-style error handling found in production code',
-        severity: 'warning',
-        confidence: confidence * 0.9,
-        suggestion: 'Use proper error handling instead of test assertions'
-      };
-    }
-    return { isValid: true, reason: 'valid_test_verification' };
-  }
-
-  validateStateManagement(catchBlock, confidence) {
-    return { isValid: true, reason: 'state_management' };
-  }
-
-  validateUnknownIntent(catchBlock, confidence) {
-    return {
-      isValid: false,
-      violationType: 'unclear_error_handling_intent',
-      message: 'Error handling intent is unclear - consider explicit error handling',
-      severity: 'info',
-      confidence: confidence,
-      suggestion: 'Make error handling intent clear through logging, rethrowing, or documentation'
-    };
-  }
-}
-
-module.exports = new C029SemanticAnalyzer();