@sun-asterisk/sunlint/rules/common/C013_no_dead_code/index.js

☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards

/**
 * C013 Rule Router - No Dead Code
 *
 * Routes analysis to the appropriate language-specific analyzer.
 * Supports: TypeScript, JavaScript, Dart
 *
 * Rule: Detect and eliminate dead code
 */

const path = require('path');

class C013Router {
  constructor() {
    this.analyzers = new Map();
    this.ruleId = 'C013';
  }

  getAnalyzer(language) {
    const normalizedLang = this.normalizeLanguage(language);

    if (!this.analyzers.has(normalizedLang)) {
      try {
        const analyzerPath = path.join(__dirname, normalizedLang, 'analyzer.js');
        const AnalyzerClass = require(analyzerPath);
        this.analyzers.set(normalizedLang, new AnalyzerClass());
      } catch (error) {
        return null;
      }
    }

    return this.analyzers.get(normalizedLang);
  }

  normalizeLanguage(language) {
    if (typeof language !== 'string') {
      return 'typescript';
    }
    const languageMap = {
      'typescript': 'typescript',
      'javascript': 'typescript',
      'ts': 'typescript',
      'js': 'typescript',
      'dart': 'dart'
    };
    return languageMap[language.toLowerCase()] || language.toLowerCase();
  }

  supportsLanguage(language) {
    if (typeof language !== 'string') return false;
    const supported = ['typescript', 'javascript', 'ts', 'js', 'dart'];
    return supported.includes(language.toLowerCase());
  }

  getSupportedLanguages() {
    return ['typescript', 'javascript', 'dart'];
  }

  async analyze(files, language, options = {}) {
    const analyzer = this.getAnalyzer(language);
    if (!analyzer) return [];
    if (typeof analyzer.analyze === 'function') {
      return analyzer.analyze(files, language, options);
    }
    return [];
  }

  async initialize(semanticEngineOrLanguage = null, semanticEngine = null) {
    let engine = semanticEngine;
    let lang = null;

    if (typeof semanticEngineOrLanguage === 'string') {
      lang = semanticEngineOrLanguage;
    } else if (semanticEngineOrLanguage && typeof semanticEngineOrLanguage === 'object') {
      engine = semanticEngineOrLanguage;
    }

    if (lang) {
      const analyzer = this.getAnalyzer(lang);
      if (analyzer && typeof analyzer.initialize === 'function') {
        await analyzer.initialize(engine);
      }
    }
  }
}

module.exports = new C013Router();