@sun-asterisk/sunlint 1.3.16 → 1.3.17

package/rules/common/C029_catch_block_logging/analyzer.js

@@ -1,140 +1,550 @@
 /**
- * C029 Analyzer - Smart Pipeline Integration
+ * C029 Analyzer - ts-morph based
  * 
- * This analyzer forwards to the Smart Pipeline for superior accuracy and performance
+ * Validates catch block logging with AST-based analysis:
+ * 1. Detects empty catch blocks
+ * 2. Validates logging presence and quality
+ * 3. Checks log levels (error vs warn vs log)
+ * 4. Validates error variable usage
+ * 5. Checks stack trace inclusion
+ * 6. Validates context data
+ * 7. Supports delegation pattern (calling helper functions)
  */
 
-const fs = require('fs');
+const { Project, SyntaxKind, Node } = require('ts-morph');
 const path = require('path');
+const fs = require('fs');
 
 class C029Analyzer {
-  constructor(options = {}) {
+  constructor(semanticEngine = null) {
     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)';
-    this.verbose = options.verbose || false;
-    
-    // Load Smart Pipeline as primary analyzer
-    this.smartPipeline = null;
-    
-    try {
-      this.smartPipeline = require('./analyzer-smart-pipeline.js');
+    this.ruleName = 'Catch Block Logging Validation';
+    this.description = 'Validates comprehensive error logging in catch blocks';
+    this.semanticEngine = semanticEngine;
+    this.project = null;
+    this.verbose = false;
+
+    // Logging patterns configuration
+    this.config = {
+      // Valid logging methods (console, logger, etc.)
+      loggingMethods: [
+        'console.error', 'console.warn', 'console.log', 'console.info', 'console.debug',
+        'logger.error', 'logger.warn', 'logger.info', 'logger.debug', 'logger.log',
+        'log.error', 'log.warn', 'log.info', 'log.debug',
+        'this.logger.error', 'this.logger.warn', 'this.logger.info',
+        'this.logError', 'this.logErrors', 'this.couponLogErrors',
+        'Logger.error', 'Logger.warn', 'Logger.info'
+      ],
+
+      // Appropriate log levels for catch blocks (should use error/warn)
+      appropriateLevels: ['error', 'warn'],
+      
+      // Inappropriate log levels (should avoid log/info/debug in catch)
+      inappropriateLevels: ['log', 'info', 'debug'],
+
+      // Error handling methods (throw, rethrow)
+      errorHandlingMethods: [
+        'throw', 'rethrow', 'handleError', 'processError', 
+        'reportError', 'trackError', 'sendError'
+      ],
+
+      // Test file patterns (more lenient checking)
+      testPatterns: ['__tests__', '.test.', '.spec.', '/test/', '/tests/', '.stories.']
+    };
+  }
+
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+
+    // Use semantic engine's project if available, otherwise create standalone
+    if (this.semanticEngine?.project) {
+      this.project = this.semanticEngine.project;
       if (this.verbose) {
-        console.log('[DEBUG] 🎯 C029: Smart Pipeline loaded (3-stage: Regex → AST → Data Flow)');
+        console.log('[DEBUG] 🎯 C029: Using semantic engine project');
       }
-    } catch (error) {
+    } else {
+      this.project = new Project({
+        compilerOptions: {
+          target: 99, // Latest
+          module: 99, // ESNext
+          allowJs: true,
+          checkJs: false,
+        },
+      });
       if (this.verbose) {
-        console.warn('[DEBUG] ⚠️ C029: Smart Pipeline failed, using fallback:', error.message);
+        console.log('[DEBUG] 🎯 C029: Created standalone ts-morph project');
       }
-      this.smartPipeline = null;
     }
   }
 
   async analyze(files, language, options = {}) {
-    // Store verbose option for this analysis
-    this.verbose = options.verbose || this.verbose || false;
+    this.verbose = options.verbose || this.verbose;
     
-    // Use Smart Pipeline as primary choice
-    if (this.smartPipeline) {
-      if (this.verbose) {
-        console.log('[DEBUG] 🎯 C029: Using Smart Pipeline (3-stage analysis)...');
-      }
-      return await this.smartPipeline.analyze(files, language, options);
-    } else {
-      if (this.verbose) {
-        console.log('[DEBUG] 🔍 C029: Using fallback regex analysis...');
-      }
-      return await this.analyzeWithRegex(files, language, options);
+    if (!this.project) {
+      await this.initialize();
     }
-  }
 
-  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);
+        const fileViolations = await this.analyzeFile(filePath, options);
         violations.push(...fileViolations);
       } catch (error) {
-        console.warn(`⚠️ C029: Error processing ${filePath}:`, error.message);
+        if (this.verbose) {
+          console.warn(`[C029] Error analyzing ${filePath}:`, error.message);
+        }
       }
     }
-    
+
+    if (this.verbose) {
+      console.log(`[C029] Total violations found: ${violations.length}`);
+    }
+
     return violations;
   }
 
-  async analyzeFile(filePath, content, language) {
+  async analyzeFile(filePath, options = {}) {
     const violations = [];
-    const lines = content.split('\n');
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
+
+    // Get or add source file
+    let sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) {
+      sourceFile = this.project.addSourceFileAtPath(filePath);
+    }
+
+    if (this.verbose) {
+      console.log(`[C029] Analyzing ${path.basename(filePath)}...`);
+    }
+
+    // Find all try statements
+    const tryStatements = sourceFile.getDescendantsOfKind(SyntaxKind.TryStatement);
+
+    if (this.verbose) {
+      console.log(`[C029] Found ${tryStatements.length} try statements`);
+    }
+
+    for (const tryStatement of tryStatements) {
+      const catchClause = tryStatement.getCatchClause();
       
-      // 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'
-          });
-        }
+      if (catchClause) {
+        const catchViolations = this.analyzeCatchClause(catchClause, filePath, sourceFile);
+        violations.push(...catchViolations);
       }
     }
+
+    return violations;
+  }
+
+  analyzeCatchClause(catchClause, filePath, sourceFile) {
+    const violations = [];
+    const block = catchClause.getBlock();
+    const variableDeclaration = catchClause.getVariableDeclaration();
     
+    // Get exception variable name (e, error, err, etc.)
+    const exceptionVar = variableDeclaration 
+      ? variableDeclaration.getName() 
+      : null;
+
+    const startLine = catchClause.getStartLineNumber();
+    const startColumn = catchClause.getStart() - catchClause.getStartLinePos() + 1;
+
+    // STAGE 1: Check if catch block is empty
+    if (this.isEmptyCatchBlock(block)) {
+      violations.push(this.createViolation(
+        filePath,
+        startLine,
+        startColumn,
+        'empty_catch',
+        'Empty catch block - errors are silently ignored',
+        'Add error logging or explicit comment explaining why error is ignored',
+        0.95
+      ));
+      return violations; // No need to check further
+    }
+
+    // STAGE 2: Find logging calls in catch block
+    const loggingInfo = this.findLoggingCalls(block, exceptionVar);
+
+    if (loggingInfo.hasLogging) {
+      // STAGE 3: Validate logging quality
+      const qualityIssues = this.validateLoggingQuality(loggingInfo, exceptionVar, filePath);
+      violations.push(...qualityIssues.map(issue => 
+        this.createViolation(
+          filePath,
+          startLine,
+          startColumn,
+          issue.type,
+          issue.message,
+          issue.suggestion,
+          issue.confidence
+        )
+      ));
+    } else {
+      // No logging found - check if there's valid error handling
+      const hasErrorHandling = this.hasValidErrorHandling(block, exceptionVar);
+      
+      if (!hasErrorHandling && !this.isTestFile(filePath)) {
+        violations.push(this.createViolation(
+          filePath,
+          startLine,
+          startColumn,
+          'no_logging',
+          exceptionVar 
+            ? `Catch block does not log exception '${exceptionVar}'`
+            : 'Catch block does not log exception',
+          'Add console.error() or logger.error() with error details',
+          0.85
+        ));
+      }
+    }
+
+    // STAGE 4: Check for unused exception variable
+    if (exceptionVar && !this.isExceptionUsed(block, exceptionVar) && !this.hasExplicitIgnoreComment(catchClause)) {
+      violations.push(this.createViolation(
+        filePath,
+        startLine,
+        startColumn,
+        'unused_exception',
+        `Exception variable '${exceptionVar}' is declared but never used`,
+        `Use '${exceptionVar}' in error logging or add comment explaining why it's ignored`,
+        0.80
+      ));
+    }
+
     return violations;
   }
 
-  extractCatchBlock(lines, startIndex) {
-    const content = [];
-    let braceCount = 0;
-    let inBlock = false;
+  /**
+   * Check if catch block is empty
+   */
+  isEmptyCatchBlock(block) {
+    const statements = block.getStatements();
     
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      content.push(line);
+    if (statements.length === 0) {
+      return true;
+    }
+
+    // Check if only contains comments
+    const text = block.getText()
+      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
+      .replace(/\/\/.*$/gm, '')          // Remove line comments
+      .replace(/\{|\}/g, '')             // Remove braces
+      .trim();
+    
+    return text.length === 0;
+  }
+
+  /**
+   * Find all logging calls in catch block
+   */
+  findLoggingCalls(block, exceptionVar) {
+    const loggingInfo = {
+      hasLogging: false,
+      calls: [],
+      usesExceptionVar: false,
+      logLevels: [],
+      hasStackTrace: false,
+      hasContextData: false
+    };
+
+    // Find all call expressions
+    const callExpressions = block.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+    for (const call of callExpressions) {
+      const expression = call.getExpression();
+      const expressionText = expression.getText();
+
+      // Check if it's a logging call
+      const isLogging = this.config.loggingMethods.some(method => 
+        expressionText.includes(method.split('.')[0]) && 
+        (expressionText.endsWith('.error') || 
+         expressionText.endsWith('.warn') ||
+         expressionText.endsWith('.log') ||
+         expressionText.endsWith('.info') ||
+         expressionText.endsWith('.debug') ||
+         expressionText.includes('logError') ||
+         expressionText.includes('logErrors'))
+      );
+
+      if (isLogging) {
+        loggingInfo.hasLogging = true;
+
+        // Extract log level
+        const logLevel = this.extractLogLevel(expressionText);
+        if (logLevel) {
+          loggingInfo.logLevels.push(logLevel);
+        }
+
+        // Check if exception variable is used in arguments
+        const args = call.getArguments();
+        const argsText = args.map(arg => arg.getText()).join(' ');
+        
+        if (exceptionVar && argsText.includes(exceptionVar)) {
+          loggingInfo.usesExceptionVar = true;
+
+          // Check for stack trace
+          if (argsText.includes(`${exceptionVar}.stack`) || 
+              argsText.includes(`${exceptionVar}.message`)) {
+            loggingInfo.hasStackTrace = true;
+          }
+        }
+
+        // Check for context data (objects, multiple arguments)
+        if (args.length > 1 || this.hasObjectLiteral(args)) {
+          loggingInfo.hasContextData = true;
+        }
+
+        loggingInfo.calls.push({
+          expression: expressionText,
+          level: logLevel,
+          arguments: argsText,
+          line: call.getStartLineNumber()
+        });
+      }
+    }
+
+    return loggingInfo;
+  }
+
+  /**
+   * Extract log level from expression (error, warn, log, info, debug)
+   */
+  extractLogLevel(expressionText) {
+    if (expressionText.includes('.error') || expressionText.includes('logError')) return 'error';
+    if (expressionText.includes('.warn')) return 'warn';
+    if (expressionText.includes('.log')) return 'log';
+    if (expressionText.includes('.info')) return 'info';
+    if (expressionText.includes('.debug')) return 'debug';
+    return null;
+  }
+
+  /**
+   * Check if arguments contain object literals (context data)
+   */
+  hasObjectLiteral(args) {
+    return args.some(arg => 
+      arg.getKind() === SyntaxKind.ObjectLiteralExpression
+    );
+  }
+
+  /**
+   * Validate logging quality
+   */
+  validateLoggingQuality(loggingInfo, exceptionVar, filePath) {
+    const issues = [];
+
+    // Issue 1: Using inappropriate log level (log/info/debug instead of error/warn)
+    const hasInappropriateLevel = loggingInfo.logLevels.some(level => 
+      this.config.inappropriateLevels.includes(level)
+    );
+
+    if (hasInappropriateLevel && !this.isTestFile(filePath)) {
+      issues.push({
+        type: 'inappropriate_log_level',
+        message: `Catch block uses console.${loggingInfo.logLevels.join('/')} instead of console.error or console.warn`,
+        suggestion: 'Use console.error() or console.warn() for error logging in catch blocks',
+        confidence: 0.75
+      });
+    }
+
+    // Issue 2: Exception variable not included in logging
+    if (exceptionVar && !loggingInfo.usesExceptionVar) {
+      issues.push({
+        type: 'exception_not_logged',
+        message: `Exception variable '${exceptionVar}' is not included in logging`,
+        suggestion: `Include '${exceptionVar}' in console.error() to preserve error details`,
+        confidence: 0.85
+      });
+    }
+
+    // Issue 3: No stack trace (optional but recommended)
+    if (exceptionVar && loggingInfo.usesExceptionVar && !loggingInfo.hasStackTrace) {
+      // This is a warning, not critical
+      issues.push({
+        type: 'missing_stack_trace',
+        message: `Logging does not include stack trace (${exceptionVar}.stack)`,
+        suggestion: `Consider logging ${exceptionVar}.stack for better debugging`,
+        confidence: 0.60
+      });
+    }
+
+    // Issue 4: No context data (optional but recommended)
+    if (!loggingInfo.hasContextData && !this.isTestFile(filePath)) {
+      issues.push({
+        type: 'missing_context_data',
+        message: 'Error logging lacks context information (user ID, request ID, parameters)',
+        suggestion: 'Add context object with relevant data: { userId, requestId, ...params, error }',
+        confidence: 0.55
+      });
+    }
+
+    return issues;
+  }
+
+  /**
+   * Check if catch block has valid error handling
+   * Accepts: throw, return with error, error handlers, delegation to any function with exception
+   */
+  hasValidErrorHandling(block, exceptionVar) {
+    const text = block.getText();
+
+    // Pattern 1: Re-throwing error
+    if (/\bthrow\b/.test(text)) {
+      return true;
+    }
+
+    // Pattern 2: Return statement with exception variable
+    // Accept: return error, return handleError(error), return {error}
+    // Reject: return null, return false (no error info)
+    if (exceptionVar && /\breturn\b/.test(text)) {
+      const returnStatements = block.getDescendantsOfKind(SyntaxKind.ReturnStatement);
+      for (const returnStmt of returnStatements) {
+        const returnExpr = returnStmt.getExpression();
+        if (returnExpr) {
+          const returnText = returnExpr.getText();
+          // Check if return expression includes exception variable
+          if (new RegExp(`\\b${exceptionVar}\\b`).test(returnText)) {
+            return true;
+          }
+        }
+      }
+    }
+
+    // Pattern 3: Common error handler functions
+    const errorHandlerPatterns = [
+      /handleError\s*\(/,
+      /processError\s*\(/,
+      /reportError\s*\(/,
+      /trackError\s*\(/,
+      /sendError\s*\(/,
+      /errorHandler\s*\(/,
+      /externalErrorHandler\s*\(/,
+      /logError\s*\(/,
+      /captureError\s*\(/,
+      /recordError\s*\(/
+    ];
+
+    if (errorHandlerPatterns.some(pattern => pattern.test(text))) {
+      return true;
+    }
+
+    // Pattern 4: Delegation - calling ANY function/helper with exception variable
+    // Examples: handleApiError(error), utils.logException(err), sendToSentry(e)
+    if (exceptionVar) {
+      const callExpressions = block.getDescendantsOfKind(SyntaxKind.CallExpression);
       
-      for (const char of line) {
-        if (char === '{') {
-          braceCount++;
-          inBlock = true;
-        } else if (char === '}') {
-          braceCount--;
-          if (braceCount === 0 && inBlock) {
-            return { content, endIndex: i };
+      for (const call of callExpressions) {
+        const args = call.getArguments();
+        
+        // Check if exception variable is passed to any function
+        for (const arg of args) {
+          const argText = arg.getText().trim();
+          
+          // Direct usage: someFunction(error)
+          if (argText === exceptionVar) {
+            return true;
+          }
+          
+          // Property access: someFunction(error.message)
+          if (argText.startsWith(exceptionVar + '.')) {
+            return true;
+          }
+          
+          // In object/array: someFunction({error: error})
+          if (new RegExp(`\\b${exceptionVar}\\b`).test(argText)) {
+            return true;
           }
         }
       }
     }
-    
-    return { content, endIndex: startIndex };
+
+    return false;
   }
 
-  isCatchBlockEmpty(content) {
-    const blockContent = content.join('\n');
+  /**
+   * Check if exception variable is used anywhere in catch block
+   */
+  isExceptionUsed(block, exceptionVar) {
+    const text = block.getText();
     
-    // 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();
+    // Simple regex to find usage of exception variable
+    const usageRegex = new RegExp(`\\b${exceptionVar}\\b`, 'g');
+    const matches = text.match(usageRegex) || [];
     
-    // Check if only contains catch declaration and braces
-    const hasOnlyStructure = /^catch\s*\([^)]*\)\s*\{\s*\}$/.test(cleanContent);
+    // Exclude the catch declaration itself
+    const catchDeclaration = new RegExp(`catch\\s*\\(\\s*${exceptionVar}\\s*\\)`, 'g');
+    const declarationMatches = text.match(catchDeclaration) || [];
+    
+    return (matches.length - declarationMatches.length) > 0;
+  }
+
+  /**
+   * Check if catch clause has explicit ignore comment
+   */
+  hasExplicitIgnoreComment(catchClause) {
+    const text = catchClause.getText();
     
-    return hasOnlyStructure;
+    const ignorePatterns = [
+      /\/\/\s*ignore/i,
+      /\/\/\s*TODO/i,
+      /\/\/\s*FIXME/i,
+      /\/\/\s*eslint-disable/i,
+      /\/\*\s*ignore/i,
+      /\/\*\s*TODO/i,
+      /\/\*\s*FIXME/i,
+      /\/\*\s*eslint-disable/i
+    ];
+
+    return ignorePatterns.some(pattern => pattern.test(text));
+  }
+
+  /**
+   * Check if file is a test file (more lenient rules)
+   */
+  isTestFile(filePath) {
+    return this.config.testPatterns.some(pattern => filePath.includes(pattern));
+  }
+
+  /**
+   * Create violation object
+   */
+  createViolation(filePath, line, column, type, message, suggestion, confidence) {
+    return {
+      ruleId: this.ruleId,
+      file: filePath,
+      line: line,
+      column: column,
+      message: message,
+      severity: this.getSeverity(type, confidence),
+      type: type,
+      confidence: confidence,
+      suggestion: suggestion,
+      analyzer: 'ts-morph'
+    };
+  }
+
+  /**
+   * Determine severity based on type and confidence
+   */
+  getSeverity(type, confidence) {
+    // High severity violations
+    const highSeverityTypes = ['empty_catch', 'no_logging', 'unused_exception'];
+    if (highSeverityTypes.includes(type) && confidence > 0.8) {
+      return 'error';
+    }
+
+    // Medium severity violations  
+    const mediumSeverityTypes = ['exception_not_logged', 'inappropriate_log_level'];
+    if (mediumSeverityTypes.includes(type) && confidence > 0.7) {
+      return 'warning';
+    }
+
+    // Low severity violations (recommendations)
+    return 'info';
   }
 }