@sun-asterisk/sunlint 1.2.1 → 1.2.2

package/rules/common/C029_catch_block_logging/multi-language-ast-engine.js

@@ -0,0 +1,700 @@
+/**
+ * C029 Multi-Language AST Engine
+ * 
+ * Provides unified AST-based analysis across multiple programming languages
+ * with language-specific adaptations for error handling patterns
+ * 
+ * Technology Showcase: Cross-language compatibility and unified analysis
+ */
+
+class C029MultiLanguageASTEngine {
+  constructor() {
+    this.ruleId = 'C029';
+    this.ruleName = 'Multi-Language Error Handling Analysis';
+    this.description = 'Unified AST-based error handling analysis across languages';
+    
+    // Language-specific parsers and configurations
+    this.languageSupport = {
+      'javascript': {
+        parser: 'babel',
+        fileExtensions: ['.js', '.jsx', '.mjs'],
+        errorHandlingPatterns: ['try-catch', 'promise-catch', 'async-catch'],
+        keywords: { try: 'try', catch: 'catch', throw: 'throw', error: 'Error' }
+      },
+      'typescript': {
+        parser: 'typescript',
+        fileExtensions: ['.ts', '.tsx'],
+        errorHandlingPatterns: ['try-catch', 'promise-catch', 'async-catch', 'generic-error'],
+        keywords: { try: 'try', catch: 'catch', throw: 'throw', error: 'Error' }
+      },
+      'java': {
+        parser: 'tree-sitter-java',
+        fileExtensions: ['.java'],
+        errorHandlingPatterns: ['try-catch-finally', 'throws-declaration', 'checked-exceptions'],
+        keywords: { try: 'try', catch: 'catch', throw: 'throw', throws: 'throws', finally: 'finally' }
+      },
+      'kotlin': {
+        parser: 'tree-sitter-kotlin',
+        fileExtensions: ['.kt', '.kts'],
+        errorHandlingPatterns: ['try-catch', 'result-type', 'elvis-operator'],
+        keywords: { try: 'try', catch: 'catch', throw: 'throw', result: 'Result' }
+      },
+      'dart': {
+        parser: 'tree-sitter-dart',
+        fileExtensions: ['.dart'],
+        errorHandlingPatterns: ['try-catch-on', 'future-catchError', 'stream-error'],
+        keywords: { try: 'try', catch: 'catch', on: 'on', throw: 'throw', rethrow: 'rethrow' }
+      },
+      'python': {
+        parser: 'tree-sitter-python',
+        fileExtensions: ['.py', '.pyw'],
+        errorHandlingPatterns: ['try-except-finally', 'context-manager', 'exception-chaining'],
+        keywords: { try: 'try', except: 'except', raise: 'raise', finally: 'finally' }
+      },
+      'go': {
+        parser: 'tree-sitter-go',
+        fileExtensions: ['.go'],
+        errorHandlingPatterns: ['error-return', 'panic-recover', 'defer-recover'],
+        keywords: { if: 'if', err: 'err', panic: 'panic', recover: 'recover', defer: 'defer' }
+      },
+      'rust': {
+        parser: 'tree-sitter-rust',
+        fileExtensions: ['.rs'],
+        errorHandlingPatterns: ['result-match', 'option-match', 'panic-catch'],
+        keywords: { match: 'match', Result: 'Result', Option: 'Option', panic: 'panic!' }
+      }
+    };
+    
+    // Cross-language error handling concepts
+    this.universalConcepts = {
+      'error_propagation': ['throw', 'raise', 'panic', 'return_error'],
+      'error_handling': ['catch', 'except', 'match', 'if_err'],
+      'resource_cleanup': ['finally', 'defer', 'drop', 'using'],
+      'error_logging': ['log', 'print', 'console', 'debug', 'warn'],
+      'error_transformation': ['wrap', 'chain', 'convert', 'map_err']
+    };
+  }
+
+  async analyze(files, language, options = {}) {
+    const violations = [];
+    console.log(`🌐 C029 Multi-Language AST: Analyzing ${files.length} ${language} files...`);
+
+    const langConfig = this.languageSupport[language.toLowerCase()];
+    if (!langConfig) {
+      console.warn(`⚠️ Language ${language} not supported by Multi-Language AST Engine`);
+      return violations;
+    }
+
+    for (const filePath of files) {
+      try {
+        const content = require('fs').readFileSync(filePath, 'utf8');
+        const languageViolations = await this.analyzeWithLanguageSupport(
+          content, filePath, language, langConfig
+        );
+        violations.push(...languageViolations);
+
+      } catch (error) {
+        console.warn(`C029 Multi-Language AST skipping ${filePath}: ${error.message}`);
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Analyze file with language-specific support
+   */
+  async analyzeWithLanguageSupport(content, filePath, language, langConfig) {
+    const violations = [];
+    
+    try {
+      // Parse with language-specific parser
+      const ast = await this.parseWithLanguageParser(content, language, langConfig);
+      
+      // Extract error handling constructs
+      const errorHandlingNodes = this.extractErrorHandlingNodes(ast, langConfig);
+      
+      // Analyze each error handling construct
+      for (const node of errorHandlingNodes) {
+        const analysis = this.analyzeErrorHandlingNode(node, content, langConfig, language);
+        
+        if (analysis.isViolation) {
+          violations.push({
+            ruleId: this.ruleId,
+            file: filePath,
+            line: analysis.line,
+            column: analysis.column,
+            message: analysis.message,
+            severity: analysis.severity,
+            code: analysis.code,
+            type: analysis.type,
+            confidence: analysis.confidence,
+            suggestion: analysis.suggestion,
+            language: language,
+            errorHandlingPattern: analysis.pattern,
+            crossLanguageInsight: analysis.insight
+          });
+        }
+      }
+      
+    } catch (parseError) {
+      console.warn(`AST parsing failed for ${filePath}: ${parseError.message}`);
+      // Fallback to regex-based analysis
+      return this.fallbackAnalysis(content, filePath, language, langConfig);
+    }
+    
+    return violations;
+  }
+
+  /**
+   * Parse content with appropriate language parser
+   */
+  async parseWithLanguageParser(content, language, langConfig) {
+    switch (language.toLowerCase()) {
+      case 'javascript':
+      case 'typescript':
+        return this.parseJavaScriptTypeScript(content, language);
+      
+      case 'java':
+        return this.parseJava(content);
+      
+      case 'kotlin':
+        return this.parseKotlin(content);
+      
+      case 'dart':
+        return this.parseDart(content);
+      
+      case 'python':
+        return this.parsePython(content);
+      
+      case 'go':
+        return this.parseGo(content);
+      
+      case 'rust':
+        return this.parseRust(content);
+      
+      default:
+        throw new Error(`Parser not implemented for ${language}`);
+    }
+  }
+
+  /**
+   * Extract error handling nodes from AST
+   */
+  extractErrorHandlingNodes(ast, langConfig) {
+    const errorNodes = [];
+    
+    // Language-specific node extraction
+    for (const pattern of langConfig.errorHandlingPatterns) {
+      const nodes = this.extractNodesForPattern(ast, pattern, langConfig);
+      errorNodes.push(...nodes);
+    }
+    
+    return errorNodes;
+  }
+
+  /**
+   * JavaScript/TypeScript AST parsing
+   */
+  parseJavaScriptTypeScript(content, language) {
+    // Simplified AST representation for JavaScript/TypeScript
+    const tryBlocks = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Find try blocks
+      if (/\btry\s*\{/.test(line)) {
+        const tryBlock = this.extractJSTryBlock(lines, i);
+        if (tryBlock) {
+          tryBlocks.push({
+            type: 'TryStatement',
+            startLine: i + 1,
+            endLine: tryBlock.endLine,
+            tryBlock: tryBlock.tryBody,
+            catchBlock: tryBlock.catchBody,
+            finallyBlock: tryBlock.finallyBody,
+            language: language
+          });
+        }
+      }
+    }
+    
+    return { errorHandlingNodes: tryBlocks };
+  }
+
+  /**
+   * Java AST parsing
+   */
+  parseJava(content) {
+    const javaNodes = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Java try-catch-finally
+      if (/\btry\s*\{/.test(line)) {
+        const tryBlock = this.extractJavaTryBlock(lines, i);
+        if (tryBlock) {
+          javaNodes.push({
+            type: 'TryStatement',
+            startLine: i + 1,
+            language: 'java',
+            tryBlock: tryBlock.tryBody,
+            catchBlocks: tryBlock.catchBlocks, // Java can have multiple catch blocks
+            finallyBlock: tryBlock.finallyBody,
+            exceptionTypes: tryBlock.exceptionTypes
+          });
+        }
+      }
+      
+      // Method throws declaration
+      if (/throws\s+\w+/.test(line)) {
+        javaNodes.push({
+          type: 'ThrowsDeclaration',
+          startLine: i + 1,
+          language: 'java',
+          exceptions: this.extractThrowsExceptions(line)
+        });
+      }
+    }
+    
+    return { errorHandlingNodes: javaNodes };
+  }
+
+  /**
+   * Kotlin AST parsing
+   */
+  parseKotlin(content) {
+    const kotlinNodes = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Kotlin try-catch
+      if (/\btry\s*\{/.test(line)) {
+        const tryBlock = this.extractKotlinTryBlock(lines, i);
+        if (tryBlock) {
+          kotlinNodes.push({
+            type: 'TryExpression',
+            startLine: i + 1,
+            language: 'kotlin',
+            tryBlock: tryBlock.tryBody,
+            catchBlock: tryBlock.catchBody,
+            finallyBlock: tryBlock.finallyBody,
+            isExpression: tryBlock.isExpression
+          });
+        }
+      }
+      
+      // Kotlin Result type usage
+      if (/Result</.test(line)) {
+        kotlinNodes.push({
+          type: 'ResultUsage',
+          startLine: i + 1,
+          language: 'kotlin',
+          resultType: this.extractResultType(line)
+        });
+      }
+    }
+    
+    return { errorHandlingNodes: kotlinNodes };
+  }
+
+  /**
+   * Dart AST parsing
+   */
+  parseDart(content) {
+    const dartNodes = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Dart try-catch-on
+      if (/\btry\s*\{/.test(line)) {
+        const tryBlock = this.extractDartTryBlock(lines, i);
+        if (tryBlock) {
+          dartNodes.push({
+            type: 'TryStatement',
+            startLine: i + 1,
+            language: 'dart',
+            tryBlock: tryBlock.tryBody,
+            catchBlocks: tryBlock.catchBlocks,
+            onBlocks: tryBlock.onBlocks,
+            finallyBlock: tryBlock.finallyBody
+          });
+        }
+      }
+      
+      // Future.catchError
+      if (/\.catchError/.test(line)) {
+        dartNodes.push({
+          type: 'FutureCatchError',
+          startLine: i + 1,
+          language: 'dart',
+          handler: this.extractCatchErrorHandler(line)
+        });
+      }
+    }
+    
+    return { errorHandlingNodes: dartNodes };
+  }
+
+  /**
+   * Python AST parsing
+   */
+  parsePython(content) {
+    const pythonNodes = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Python try-except-finally
+      if (/^try:/.test(line)) {
+        const tryBlock = this.extractPythonTryBlock(lines, i);
+        if (tryBlock) {
+          pythonNodes.push({
+            type: 'TryStatement',
+            startLine: i + 1,
+            language: 'python',
+            tryBlock: tryBlock.tryBody,
+            exceptBlocks: tryBlock.exceptBlocks,
+            elseBlock: tryBlock.elseBody,
+            finallyBlock: tryBlock.finallyBody
+          });
+        }
+      }
+      
+      // Context manager (with statement)
+      if (/^with\s+/.test(line)) {
+        pythonNodes.push({
+          type: 'WithStatement',
+          startLine: i + 1,
+          language: 'python',
+          contextManager: this.extractContextManager(line)
+        });
+      }
+    }
+    
+    return { errorHandlingNodes: pythonNodes };
+  }
+
+  /**
+   * Go AST parsing
+   */
+  parseGo(content) {
+    const goNodes = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Go error checking pattern
+      if (/if\s+err\s*!=\s*nil/.test(line)) {
+        goNodes.push({
+          type: 'ErrorCheck',
+          startLine: i + 1,
+          language: 'go',
+          errorVariable: 'err',
+          checkPattern: 'nil_comparison'
+        });
+      }
+      
+      // Panic-recover pattern
+      if (/\bpanic\s*\(/.test(line)) {
+        goNodes.push({
+          type: 'PanicStatement',
+          startLine: i + 1,
+          language: 'go',
+          panicValue: this.extractPanicValue(line)
+        });
+      }
+      
+      if (/\brecover\s*\(\s*\)/.test(line)) {
+        goNodes.push({
+          type: 'RecoverStatement',
+          startLine: i + 1,
+          language: 'go'
+        });
+      }
+    }
+    
+    return { errorHandlingNodes: goNodes };
+  }
+
+  /**
+   * Analyze specific error handling node
+   */
+  analyzeErrorHandlingNode(node, content, langConfig, language) {
+    switch (node.type) {
+      case 'TryStatement':
+      case 'TryExpression':
+        return this.analyzeTryStatement(node, content, langConfig, language);
+      
+      case 'ErrorCheck':
+        return this.analyzeErrorCheck(node, content, langConfig, language);
+      
+      case 'ThrowsDeclaration':
+        return this.analyzeThrowsDeclaration(node, content, langConfig, language);
+      
+      case 'ResultUsage':
+        return this.analyzeResultUsage(node, content, langConfig, language);
+      
+      case 'FutureCatchError':
+        return this.analyzeFutureCatchError(node, content, langConfig, language);
+      
+      case 'WithStatement':
+        return this.analyzeWithStatement(node, content, langConfig, language);
+      
+      case 'PanicStatement':
+        return this.analyzePanicStatement(node, content, langConfig, language);
+      
+      default:
+        return { isViolation: false, reason: 'unknown_node_type' };
+    }
+  }
+
+  /**
+   * Analyze try statement (universal pattern)
+   */
+  analyzeTryStatement(node, content, langConfig, language) {
+    const catchBlock = node.catchBlock || node.catchBlocks?.[0];
+    
+    if (!catchBlock || this.isEmpty(catchBlock)) {
+      return {
+        isViolation: true,
+        type: 'empty_catch_block',
+        message: `Empty ${langConfig.keywords.catch || 'catch'} block in ${language}`,
+        severity: 'error',
+        line: node.startLine,
+        column: 1,
+        code: this.getNodeCode(node, content),
+        confidence: 0.9,
+        suggestion: this.generateLanguageSpecificSuggestion(language, 'empty_catch'),
+        pattern: 'try-catch',
+        insight: `Cross-language analysis: Empty error handling detected`
+      };
+    }
+    
+    // Check for logging
+    const hasLogging = this.hasErrorLogging(catchBlock, langConfig, language);
+    if (!hasLogging) {
+      return {
+        isViolation: true,
+        type: 'missing_error_logging',
+        message: `Missing error logging in ${language} ${langConfig.keywords.catch || 'catch'} block`,
+        severity: 'warning',
+        line: node.startLine,
+        column: 1,
+        code: this.getNodeCode(node, content),
+        confidence: 0.7,
+        suggestion: this.generateLanguageSpecificSuggestion(language, 'add_logging'),
+        pattern: 'try-catch',
+        insight: `Cross-language best practice: Add error logging for debugging`
+      };
+    }
+    
+    return { isViolation: false, reason: 'proper_error_handling' };
+  }
+
+  /**
+   * Analyze Go error check pattern
+   */
+  analyzeErrorCheck(node, content, langConfig, language) {
+    const lines = content.split('\n');
+    const errorHandlingLine = lines[node.startLine]; // Line after the error check
+    
+    if (!errorHandlingLine || errorHandlingLine.trim() === '') {
+      return {
+        isViolation: true,
+        type: 'go_empty_error_handling',
+        message: 'Empty error handling after error check in Go',
+        severity: 'error',
+        line: node.startLine + 1,
+        column: 1,
+        code: lines.slice(node.startLine - 1, node.startLine + 2).join('\n'),
+        confidence: 0.9,
+        suggestion: 'Add error handling logic (logging, return, panic, etc.)',
+        pattern: 'error-return',
+        insight: 'Go idiom: Always handle checked errors explicitly'
+      };
+    }
+    
+    return { isViolation: false, reason: 'go_error_handled' };
+  }
+
+  /**
+   * Generate language-specific suggestions
+   */
+  generateLanguageSpecificSuggestion(language, violationType) {
+    const suggestions = {
+      'javascript': {
+        'empty_catch': 'Add console.error(error) or appropriate error handling',
+        'add_logging': 'Consider adding console.error(error) or using a logging library'
+      },
+      'typescript': {
+        'empty_catch': 'Add console.error(error) with proper typing',
+        'add_logging': 'Consider using a typed logging interface'
+      },
+      'java': {
+        'empty_catch': 'Add logger.error() or throw new RuntimeException()',
+        'add_logging': 'Use logger.error() or System.err.println()'
+      },
+      'kotlin': {
+        'empty_catch': 'Add println(error) or use Result<T> for error handling',
+        'add_logging': 'Consider using logging framework or Result type'
+      },
+      'dart': {
+        'empty_catch': 'Add print(error) or rethrow for debugging',
+        'add_logging': 'Use print() for simple cases or logging package'
+      },
+      'python': {
+        'empty_catch': 'Add print(e) or logging.error(e)',
+        'add_logging': 'Use logging.exception() to include stack trace'
+      },
+      'go': {
+        'empty_catch': 'Add fmt.Printf("Error: %v", err) or return err',
+        'add_logging': 'Use log.Printf() or return the error'
+      },
+      'rust': {
+        'empty_catch': 'Use eprintln!() or return Err() for proper error handling',
+        'add_logging': 'Consider using log crate or eprintln! macro'
+      }
+    };
+    
+    return suggestions[language]?.[violationType] || 'Add appropriate error handling for this language';
+  }
+
+  // Helper methods for language-specific parsing
+  extractJSTryBlock(lines, startIndex) {
+    // Simplified extraction for JavaScript/TypeScript try blocks
+    let braceCount = 0;
+    let inTry = false;
+    let tryBody = '';
+    let catchBody = '';
+    let finallyBody = '';
+    let currentSection = 'try';
+    
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Count braces to find block boundaries
+      braceCount += (line.match(/\{/g) || []).length;
+      braceCount -= (line.match(/\}/g) || []).length;
+      
+      if (line.includes('catch')) currentSection = 'catch';
+      if (line.includes('finally')) currentSection = 'finally';
+      
+      if (currentSection === 'try') tryBody += line + '\n';
+      else if (currentSection === 'catch') catchBody += line + '\n';
+      else if (currentSection === 'finally') finallyBody += line + '\n';
+      
+      if (braceCount === 0 && i > startIndex) {
+        return {
+          endLine: i + 1,
+          tryBody: tryBody.trim(),
+          catchBody: catchBody.trim(),
+          finallyBody: finallyBody.trim()
+        };
+      }
+    }
+    
+    return null;
+  }
+
+  isEmpty(blockContent) {
+    if (!blockContent) return true;
+    
+    const cleaned = blockContent
+      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
+      .replace(/\/\/.*$/gm, '')         // Remove line comments
+      .replace(/\s+/g, '')              // Remove whitespace
+      .replace(/[{}]/g, '');            // Remove braces
+    
+    return cleaned.length === 0;
+  }
+
+  hasErrorLogging(blockContent, langConfig, language) {
+    if (!blockContent) return false;
+    
+    // Language-specific logging patterns
+    const loggingPatterns = {
+      'javascript': /console\.(log|error|warn|debug)/,
+      'typescript': /console\.(log|error|warn|debug)/,
+      'java': /(logger?\.(error|warn|info|debug)|System\.(err|out)\.print)/,
+      'kotlin': /(println|print|Log\.[dewi])/,
+      'dart': /(print|debugPrint|log\.)/,
+      'python': /(print|logging\.(error|warning|info|debug)|logger\.(error|warning))/,
+      'go': /(fmt\.(Print|Error)|log\.(Print|Error))/,
+      'rust': /(println!|eprintln!|log::|debug!|error!)/
+    };
+    
+    const pattern = loggingPatterns[language.toLowerCase()];
+    return pattern ? pattern.test(blockContent) : false;
+  }
+
+  getNodeCode(node, content) {
+    const lines = content.split('\n');
+    const startLine = Math.max(0, node.startLine - 1);
+    const endLine = Math.min(lines.length, node.endLine || node.startLine + 2);
+    
+    return lines.slice(startLine, endLine).join('\n');
+  }
+
+  fallbackAnalysis(content, filePath, language, langConfig) {
+    // Fallback to simple regex-based analysis when AST parsing fails
+    console.log(`📄 Falling back to regex analysis for ${filePath}`);
+    
+    const violations = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      // Universal empty catch pattern
+      if (/catch\s*\([^)]*\)\s*\{\s*\}/.test(line)) {
+        violations.push({
+          ruleId: this.ruleId,
+          file: filePath,
+          line: i + 1,
+          column: 1,
+          message: `Empty catch block detected (${language} - fallback analysis)`,
+          severity: 'error',
+          code: line.trim(),
+          type: 'empty_catch_fallback',
+          confidence: 0.6,
+          suggestion: this.generateLanguageSpecificSuggestion(language, 'empty_catch'),
+          language: language,
+          crossLanguageInsight: 'Fallback analysis - consider AST-based analysis for better accuracy'
+        });
+      }
+    }
+    
+    return violations;
+  }
+
+  // Placeholder methods for additional language parsers (to be implemented)
+  parseRust(content) { return { errorHandlingNodes: [] }; }
+  extractJavaTryBlock(lines, startIndex) { return null; }
+  extractKotlinTryBlock(lines, startIndex) { return null; }
+  extractDartTryBlock(lines, startIndex) { return null; }
+  extractPythonTryBlock(lines, startIndex) { return null; }
+  extractThrowsExceptions(line) { return []; }
+  extractResultType(line) { return ''; }
+  extractCatchErrorHandler(line) { return ''; }
+  extractContextManager(line) { return ''; }
+  extractPanicValue(line) { return ''; }
+  extractNodesForPattern(ast, pattern, langConfig) { return []; }
+  analyzeThrowsDeclaration(node, content, langConfig, language) { return { isViolation: false }; }
+  analyzeResultUsage(node, content, langConfig, language) { return { isViolation: false }; }
+  analyzeFutureCatchError(node, content, langConfig, language) { return { isViolation: false }; }
+  analyzeWithStatement(node, content, langConfig, language) { return { isViolation: false }; }
+  analyzePanicStatement(node, content, langConfig, language) { return { isViolation: false }; }
+}
+
+module.exports = new C029MultiLanguageASTEngine();