@sun-asterisk/sunlint 1.1.7 → 1.2.0

package/rules/common/C010_limit_block_nesting/analyzer.js

@@ -1,389 +0,0 @@
-/**
- * C010 Rule: Limit Block Nesting Depth
- * Prevents deep nesting of blocks (if/for/while/switch/try) to improve code readability
- * Maximum recommended depth: 3 levels
- * Severity: warning
- * Category: Maintainability
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class C010LimitBlockNestingAnalyzer {
-  constructor() {
-    this.ruleId = 'C010';
-    this.ruleName = 'Limit Block Nesting';
-    this.description = 'Do not exceed maximum block nesting depth for better readability';
-    this.severity = 'warning';
-    this.maxDepth = 3;
-    
-    // Control flow blocks that create nesting - Match ESLint rule exactly
-    // Only: if, for, while, do-while, switch, try-catch statements
-    this.blockPatterns = [
-      // if/else patterns - handle both same-line and multi-line blocks
-      { pattern: /^\s*if\s*\(.*\)\s*\{/, type: 'if', opens: true },
-      { pattern: /^\s*if\s*\(.*\)\s*$/, type: 'if-pending', opens: false, needsBrace: true },
-      { pattern: /^\s*else\s*if\s*\(.*\)\s*\{/, type: 'else-if', opens: true },
-      { pattern: /^\s*else\s*if\s*\(.*\)\s*$/, type: 'else-if-pending', opens: false, needsBrace: true },
-      { pattern: /^\s*else\s*\{/, type: 'else', opens: true },
-      { pattern: /^\s*else\s*$/, type: 'else-pending', opens: false, needsBrace: true },
-      
-      // Loop patterns - handle both same-line and multi-line blocks
-      { pattern: /^\s*for\s*\(.*\)\s*\{/, type: 'for', opens: true },
-      { pattern: /^\s*for\s*\(.*\)\s*$/, type: 'for-pending', opens: false, needsBrace: true },
-      { pattern: /^\s*while\s*\(.*\)\s*\{/, type: 'while', opens: true },
-      { pattern: /^\s*while\s*\(.*\)\s*$/, type: 'while-pending', opens: false, needsBrace: true },
-      { pattern: /^\s*do\s*\{/, type: 'do-while', opens: true },
-      { pattern: /^\s*do\s*$/, type: 'do-while-pending', opens: false, needsBrace: true },
-      
-      // Switch statements (not individual case blocks)
-      { pattern: /^\s*switch\s*\(.*\)\s*\{/, type: 'switch', opens: true },
-      { pattern: /^\s*switch\s*\(.*\)\s*$/, type: 'switch-pending', opens: false, needsBrace: true },
-      
-      // Try-catch patterns
-      { pattern: /^\s*try\s*\{/, type: 'try', opens: true },
-      { pattern: /^\s*try\s*$/, type: 'try-pending', opens: false, needsBrace: true },
-      { pattern: /^\s*catch\s*\(.*\)\s*\{/, type: 'catch', opens: true },
-      { pattern: /^\s*catch\s*\(.*\)\s*$/, type: 'catch-pending', opens: false, needsBrace: true },
-      { pattern: /^\s*finally\s*\{/, type: 'finally', opens: true },
-      { pattern: /^\s*finally\s*$/, type: 'finally-pending', opens: false, needsBrace: true },
-      
-      // With statements (rarely used but included for completeness)
-      { pattern: /^\s*with\s*\(.*\)\s*\{/, type: 'with', opens: true },
-      { pattern: /^\s*with\s*\(.*\)\s*$/, type: 'with-pending', opens: false, needsBrace: true },
-      
-      // Standalone opening brace (follows pending blocks)
-      { pattern: /^\s*\{\s*$/, type: 'brace-block', opens: true }
-    ];
-
-    // Track pending blocks that expect a brace on next line
-    this.pendingBlocks = [];
-
-    // Patterns for inline blocks (without braces)
-    this.inlineBlockPatterns = [
-      { pattern: /^\s*if\s*\(.*\)\s*[^{]/, type: 'if-inline' },
-      { pattern: /^\s*else\s+if\s*\(.*\)\s*[^{]/, type: 'else-if-inline' },
-      { pattern: /^\s*else\s+[^{]/, type: 'else-inline' },
-      { pattern: /^\s*for\s*\(.*\)\s*[^{]/, type: 'for-inline' },
-      { pattern: /^\s*while\s*\(.*\)\s*[^{]/, type: 'while-inline' }
-    ];
-  }
-
-  async analyze(files, language, config = {}) {
-    const violations = [];
-    
-    if (config?.rules?.C010?.maxDepth) {
-      this.maxDepth = config.rules.C010.maxDepth;
-    }
-
-    for (const filePath of files) {
-      try {
-        if (this.isTestFile(filePath)) {
-          continue;
-        }
-        
-        const fileContent = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, fileContent, language, config);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`C010 analysis error for ${filePath}:`, error.message);
-      }
-    }
-    
-    return violations;
-  }
-
-  async analyzeFile(filePath, fileContent, language, config) {
-    const violations = [];
-    
-    // Reset pending blocks for each file
-    this.pendingBlocks = [];
-    
-    try {
-      const lines = fileContent.split('\n');
-      let controlFlowStack = []; // Only track control flow blocks
-      let commentState = { inMultiLine: false, startChar: 0 };
-
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const lineNumber = i + 1;
-        
-        // Update comment state and skip if in comment
-        commentState = this.updateCommentState(line, commentState);
-        if (this.isLineInComment(line, commentState)) {
-          continue;
-        }
-        
-        const trimmedLine = line.trim();
-        if (!trimmedLine) continue;
-        
-        // Track control flow statements
-        const controlFlowMatch = this.detectControlFlow(trimmedLine);
-        if (controlFlowMatch) {
-          // Check if this line has opening brace (same line)
-          if (trimmedLine.includes('{')) {
-            controlFlowStack.push({
-              type: controlFlowMatch.type,
-              line: lineNumber,
-              column: this.getBlockStartColumn(line)
-            });
-            
-            // Check depth violation at the control flow statement
-            if (controlFlowStack.length > this.maxDepth) {
-              violations.push(this.createViolation(
-                filePath, 
-                lineNumber, 
-                this.getBlockStartColumn(line), 
-                line, 
-                controlFlowStack.length, 
-                controlFlowStack
-              ));
-            }
-          } else {
-            // Look ahead for opening brace on next line
-            let braceLineIndex = -1;
-            for (let j = i + 1; j < Math.min(i + 3, lines.length); j++) {
-              if (lines[j].trim() === '{') {
-                braceLineIndex = j;
-                break;
-              }
-              if (lines[j].trim() !== '') break; // Stop if non-empty, non-brace line
-            }
-            
-            if (braceLineIndex >= 0) {
-              controlFlowStack.push({
-                type: controlFlowMatch.type,
-                line: braceLineIndex + 1,
-                column: this.getBlockStartColumn(lines[braceLineIndex])
-              });
-              
-              // Check depth violation at the opening brace
-              if (controlFlowStack.length > this.maxDepth) {
-                violations.push(this.createViolation(
-                  filePath, 
-                  braceLineIndex + 1, 
-                  this.getBlockStartColumn(lines[braceLineIndex]), 
-                  lines[braceLineIndex], 
-                  controlFlowStack.length, 
-                  controlFlowStack
-                ));
-              }
-            }
-          }
-        }
-        
-        // Handle closing braces - only remove if we have control flow blocks
-        const closeBraces = (line.match(/\}/g) || []).length;
-        for (let j = 0; j < closeBraces && controlFlowStack.length > 0; j++) {
-          controlFlowStack.pop();
-        }
-      }
-      
-    } catch (error) {
-      console.warn(`C010 analysis error for ${filePath}:`, error.message);
-    }
-
-    return violations;
-  }
-  
-  detectControlFlow(line) {
-    // Match control flow keywords that create nesting
-    const patterns = [
-      { pattern: /^\s*if\s*\(/, type: 'if' },
-      { pattern: /^\s*else\s+if\s*\(/, type: 'else-if' },
-      { pattern: /^\s*else\s*$/, type: 'else' },
-      { pattern: /^\s*for\s*\(/, type: 'for' },
-      { pattern: /^\s*while\s*\(/, type: 'while' },
-      { pattern: /^\s*do\s*$/, type: 'do-while' },
-      { pattern: /^\s*switch\s*\(/, type: 'switch' },
-      { pattern: /^\s*try\s*$/, type: 'try' },
-      { pattern: /^\s*catch\s*\(/, type: 'catch' },
-      { pattern: /^\s*finally\s*$/, type: 'finally' },
-      { pattern: /^\s*with\s*\(/, type: 'with' },
-      // Handle closing brace followed by control flow
-      { pattern: /^\s*}\s*else\s+if\s*\(/, type: 'else-if' },
-      { pattern: /^\s*}\s*else\s*$/, type: 'else' },
-      { pattern: /^\s*}\s*catch\s*\(/, type: 'catch' },
-      { pattern: /^\s*}\s*finally\s*$/, type: 'finally' }
-    ];
-    
-    for (const pattern of patterns) {
-      if (pattern.pattern.test(line)) {
-        return { type: pattern.type };
-      }
-    }
-    
-    return null;
-  }
-  
-  updateCommentState(line, currentState) {
-    let { inMultiLine, startChar } = currentState;
-    let pos = startChar;
-    
-    while (pos < line.length) {
-      if (!inMultiLine) {
-        // Check for single line comment
-        if (line.substr(pos, 2) === '//') {
-          return { inMultiLine: false, startChar: line.length };
-        }
-        // Check for multi-line comment start
-        if (line.substr(pos, 2) === '/*') {
-          inMultiLine = true;
-          pos += 2;
-          continue;
-        }
-      } else {
-        // Check for multi-line comment end
-        if (line.substr(pos, 2) === '*/') {
-          inMultiLine = false;
-          pos += 2;
-          continue;
-        }
-      }
-      pos++;
-    }
-    
-    return { inMultiLine, startChar: 0 };
-  }
-  
-  isLineInComment(line, commentState) {
-    const trimmed = line.trim();
-    
-    // Single line comment
-    if (trimmed.startsWith('//')) return true;
-    
-    // JSDoc style comment
-    if (trimmed.startsWith('*') && !trimmed.startsWith('*/')) return true;
-    
-    // In multi-line comment
-    if (commentState.inMultiLine) {
-      // Unless the line ends the comment, it's a comment line
-      return !line.includes('*/');
-    }
-    
-    return false;
-  }
-  
-  detectBlockOpening(trimmedLine, fullLine) {
-    // First check if this is a standalone opening brace that follows a pending block
-    if (trimmedLine === '{' && this.pendingBlocks.length > 0) {
-      const pendingBlock = this.pendingBlocks.pop();
-      return {
-        opens: true,
-        type: pendingBlock.type.replace('-pending', ''),
-        column: this.getBlockStartColumn(fullLine),
-        inline: false
-      };
-    }
-    
-    // Check for block patterns
-    for (const blockPattern of this.blockPatterns) {
-      if (blockPattern.pattern.test(trimmedLine)) {
-        if (blockPattern.needsBrace) {
-          // This is a pending block, add to pending list
-          this.pendingBlocks.push({
-            type: blockPattern.type,
-            line: fullLine
-          });
-          return { opens: false };
-        } else {
-          return {
-            opens: blockPattern.opens,
-            type: blockPattern.type,
-            column: this.getBlockStartColumn(fullLine),
-            inline: false
-          };
-        }
-      }
-    }
-    
-    return { opens: false };
-  }
-  
-  detectInlineBlock(trimmedLine) {
-    // Skip if line ends with { or ;
-    if (trimmedLine.endsWith('{') || trimmedLine.endsWith(';')) {
-      return null;
-    }
-    
-    for (const pattern of this.inlineBlockPatterns) {
-      if (pattern.pattern.test(trimmedLine)) {
-        return { type: pattern.type };
-      }
-    }
-    
-    return null;
-  }
-  
-  isClosingBrace(line) {
-    // Match closing brace, possibly followed by else/catch/finally
-    return /^\s*}\s*(else|catch|finally)?\s*(\{|$)/.test(line);
-  }
-  
-  handleClosingBrace(blockStack) {
-    if (blockStack.length > 0) {
-      // Remove the most recent block
-      blockStack.pop();
-    }
-  }
-  
-  calculateEffectiveDepth(blockStack) {
-    // Count only non-inline blocks for depth calculation
-    return blockStack.filter(block => !block.inline).length;
-  }
-  
-  getBlockStartColumn(line) {
-    const match = line.match(/^\s*/);
-    return match ? match[0].length + 1 : 1;
-  }
-  
-  isTestFile(filePath) {
-    const testPatterns = [
-      /\.test\.(js|ts|jsx|tsx)$/,
-      /\.spec\.(js|ts|jsx|tsx)$/,
-      /\/__tests__\//,
-      /\/tests?\//,
-      /\.e2e\./,
-      /test\.config\./,
-      /jest\.config\./,
-      /vitest\.config\./,
-      /cypress\//
-    ];
-    
-    return testPatterns.some(pattern => pattern.test(filePath));
-  }
-  
-  createViolation(filePath, lineNumber, column, sourceLine, depth, blockStack) {
-    return {
-      ruleId: this.ruleId,
-      severity: this.severity,
-      message: `Block nesting depth ${depth} exceeds maximum of ${this.maxDepth}. Consider refactoring to reduce complexity.`,
-      filePath: filePath,
-      line: lineNumber,
-      column: column,
-      source: sourceLine.trim(),
-      suggestion: this.getSuggestion(depth),
-      nestingStack: blockStack.map(b => ({ 
-        type: b.type, 
-        line: b.line,
-        inline: b.inline || false
-      }))
-    };
-  }
-  
-  getSuggestion(currentDepth) {
-    const suggestions = [
-      "Extract nested logic into separate functions",
-      "Use early returns to reduce nesting",
-      "Consider using guard clauses",
-      "Break complex conditions into meaningful variables",
-      "Use strategy pattern for complex conditional logic",
-      "Consider using a state machine for complex flow control"
-    ];
-    
-    const index = Math.min(currentDepth - this.maxDepth - 1, suggestions.length - 1);
-    return suggestions[Math.max(0, index)];
-  }
-}
-
-module.exports = C010LimitBlockNestingAnalyzer;

package/rules/common/C013_no_dead_code/analyzer.js

@@ -1,206 +0,0 @@
-/**
- * Heuristic analyzer for: C013 – Do not leave dead code
- * Purpose: Detect unreachable code after return, throw, break, continue statements
- */
-
-class C013Analyzer {
-  constructor() {
-    this.ruleId = 'C013';
-    this.ruleName = 'No Dead Code';
-    this.description = 'Avoid unreachable code after return, throw, break, continue statements';
-  }
-
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🔍 Running C013 analysis on ${require('path').basename(filePath)}`);
-      }
-      
-      try {
-        const content = require('fs').readFileSync(filePath, 'utf8');
-        const fileViolations = this.analyzeFile(content, filePath);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`⚠️ Failed to analyze ${filePath}: ${error.message}`);
-      }
-    }
-    
-    return violations;
-  }
-
-  analyzeFile(content, filePath) {
-    const violations = [];
-    const lines = content.split('\n');
-    
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      // Skip empty lines and comments
-      if (!line || line.startsWith('//') || line.startsWith('/*') || line.startsWith('*')) {
-        continue;
-      }
-      
-      // Only look for return statements (not throw in catch blocks)
-      if (this.isSimpleReturn(line)) {
-        // Check if there are non-comment, non-empty lines after this return
-        // within the same function scope
-        const unreachableLines = this.findUnreachableCodeSimple(lines, i);
-        
-        for (const unreachableLine of unreachableLines) {
-          violations.push({
-            file: filePath,
-            line: unreachableLine + 1,
-            column: 1,
-            message: `Unreachable code detected after return statement. Remove dead code or restructure logic.`,
-            severity: 'warning',
-            ruleId: this.ruleId
-          });
-        }
-      }
-    }
-    
-    return violations;
-  }
-  
-  isSimpleReturn(line) {
-    // Only detect simple return statements that actually complete, not multiline returns
-    const cleanLine = line.replace(/;?\s*$/, '');
-    
-    return (
-      // Complete return statements with semicolon or at end of line
-      /^return\s*;?\s*$/.test(cleanLine) ||
-      /^return\s+[^{}\[\(]+;?\s*$/.test(cleanLine) ||
-      // Single-line returns with simple values  
-      /^return\s+(true|false|null|undefined|\d+|"[^"]*"|'[^']*')\s*;?\s*$/.test(cleanLine) ||
-      // Handle single-line conditional returns
-      /}\s*else\s*return\s+[^{}\[\(]+;?\s*$/.test(line) ||
-      /}\s*return\s+[^{}\[\(]+;?\s*$/.test(line)
-    );
-  }
-  
-  findUnreachableCodeSimple(lines, terminatingLineIndex) {
-    const unreachableLines = [];
-    
-    // Look for code after the return statement until we hit a closing brace or new function
-    for (let i = terminatingLineIndex + 1; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      // Skip empty lines and comments
-      if (!line || line.startsWith('//') || line.startsWith('/*') || line.startsWith('*')) {
-        continue;
-      }
-      
-      // Stop if we hit a closing brace (end of function/block)
-      if (line === '}' || line === '};' || line.startsWith('} ')) {
-        break;
-      }
-      
-      // Stop if we hit catch/finally (these are reachable)
-      if (line.includes('catch') || line.includes('finally')) {
-        break;
-      }
-      
-      // Stop if we hit a new function or method definition
-      if (line.includes('function') || line.includes('=>') || line.match(/^\w+\s*\(/)) {
-        break;
-      }
-      
-      // This looks like unreachable code
-      if (this.isExecutableCode(line)) {
-        unreachableLines.push(i);
-      }
-    }
-    
-    return unreachableLines;
-  }
-  
-  findUnreachableCode(lines, terminatingLineIndex, content) {
-    const unreachableLines = [];
-    let braceDepth = this.getCurrentBraceDepth(lines, terminatingLineIndex, content);
-    let currentDepth = braceDepth;
-    let inTryCatchFinally = false;
-    
-    // Check if we're inside a try-catch-finally context
-    const contextBefore = lines.slice(0, terminatingLineIndex).join(' ');
-    if (contextBefore.includes('try') || contextBefore.includes('catch') || contextBefore.includes('finally')) {
-      // Need more sophisticated detection of try-catch-finally blocks
-      inTryCatchFinally = true;
-    }
-    
-    // Look for unreachable code after the terminating statement
-    for (let i = terminatingLineIndex + 1; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      // Skip empty lines and comments
-      if (!line || line.startsWith('//') || line.startsWith('/*') || line.startsWith('*')) {
-        continue;
-      }
-      
-      // Special handling for try-catch-finally: finally blocks are always reachable
-      if (line.includes('finally') || (inTryCatchFinally && line === '}')) {
-        // Don't mark finally blocks or their closing braces as unreachable
-        if (line.includes('finally')) {
-          inTryCatchFinally = false; // Reset after seeing finally
-        }
-        continue;
-      }
-      
-      // Update brace depth
-      const openBraces = (line.match(/{/g) || []).length;
-      const closeBraces = (line.match(/}/g) || []).length;
-      currentDepth += openBraces - closeBraces;
-      
-      // If we've exited the current block scope, stop looking
-      if (currentDepth < braceDepth) {
-        break;
-      }
-      
-      // If we're still in the same block scope, this is potentially unreachable
-      if (currentDepth === braceDepth) {
-        // Check if this line contains executable code (not just closing braces)
-        if (this.isExecutableCode(line)) {
-          unreachableLines.push(i);
-        }
-      }
-    }
-    
-    return unreachableLines;
-  }
-  
-  getCurrentBraceDepth(lines, lineIndex, content) {
-    // Calculate the brace depth at the given line
-    let depth = 0;
-    const textUpToLine = lines.slice(0, lineIndex + 1).join('\n');
-    
-    for (let char of textUpToLine) {
-      if (char === '{') depth++;
-      if (char === '}') depth--;
-    }
-    
-    return depth;
-  }
-  
-  isExecutableCode(line) {
-    // Exclude lines that are just structural (closing braces, etc.)
-    if (line === '}' || line === '};' || line === '},' || line.match(/^\s*}\s*$/)) {
-      return false;
-    }
-    
-    // Exclude catch/finally blocks (they are reachable)
-    if (line.includes('catch') || line.includes('finally')) {
-      return false;
-    }
-    
-    // Exclude case/default statements (they might be reachable)
-    if (line.startsWith('case ') || line.startsWith('default:')) {
-      return false;
-    }
-    
-    // This looks like executable code
-    return true;
-  }
-}
-
-module.exports = C013Analyzer;