@sun-asterisk/sunlint 1.3.0 → 1.3.2

package/rules/common/C010_limit_block_nesting/analyzer.js

@@ -1,389 +1,233 @@
 /**
- * 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
+ * C010 Main Analyzer - Block Nesting Detection
+ * Primary: Symbol-based analysis (when available)
+ * Fallback: Regex-based for all other cases
  */
 
-const fs = require('fs');
-const path = require('path');
+const C010SymbolBasedAnalyzer = require('./symbol-based-analyzer.js');
+const C010RegexBasedAnalyzer = require('./regex-based-analyzer.js');
 
-class C010LimitBlockNestingAnalyzer {
-  constructor() {
+class C010Analyzer {
+  constructor(options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C010] Constructor called with options:`, !!options);
+      console.log(`🔧 [C010] Options type:`, typeof options, Object.keys(options || {}));
+    }
+    
     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;
+    this.description = 'Block nesting depth should not exceed maximum allowed levels for better readability';
+    this.semanticEngine = options.semanticEngine || null;
+    this.verbose = options.verbose || false;
+    
+    // Configuration
+    this.config = {
+      useSymbolBased: true,      // Primary approach
+      fallbackToRegex: true,     // Only when symbol fails completely
+      symbolBasedOnly: false     // Can be set to true for pure mode
+    };
     
-    // 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' }
-    ];
+    // Initialize both analyzers
+    try {
+      this.symbolAnalyzer = new C010SymbolBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C010] Symbol analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C010] Error creating symbol analyzer:`, error);
+    }
+    
+    try {
+      this.regexAnalyzer = new C010RegexBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C010] Regex analyzer created successfully`);
+      }
+    } catch (error) {
+      console.error(`🔧 [C010] Error creating regex analyzer:`, error);
+    }
+    
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C010] Constructor completed`);
+    }
   }
 
-  async analyze(files, language, config = {}) {
-    const violations = [];
+  /**
+   * Initialize with semantic engine
+   */
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
+    
+    // Initialize both analyzers
+    await this.symbolAnalyzer.initialize(semanticEngine);
+    await this.regexAnalyzer.initialize(semanticEngine);
+    
+    // Ensure verbose flag is propagated
+    this.regexAnalyzer.verbose = this.verbose;
+    this.symbolAnalyzer.verbose = this.verbose;
     
-    if (config?.rules?.C010?.maxDepth) {
-      this.maxDepth = config.rules.C010.maxDepth;
+    if (this.verbose) {
+      console.log(`🔧 [C010 Hybrid] Analyzer initialized - verbose: ${this.verbose}`);
     }
+  }
 
+  async analyze(files, language, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C010] *** NEW HYBRID ANALYZE METHOD CALLED ***`);
+      console.log(`🔧 [C010] analyze() method called with ${files.length} files, language: ${language}`);
+    }
+    
+    const violations = [];
+    
     for (const filePath of files) {
       try {
-        if (this.isTestFile(filePath)) {
-          continue;
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C010] Processing file: ${filePath}`);
         }
         
-        const fileContent = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, fileContent, language, config);
+        const fileViolations = await this.analyzeFile(filePath, options);
         violations.push(...fileViolations);
+        
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C010] File ${filePath}: Found ${fileViolations.length} violations`);
+        }
       } catch (error) {
-        console.warn(`C010 analysis error for ${filePath}:`, error.message);
+        console.warn(`❌ [C010] Analysis failed for ${filePath}:`, error.message);
       }
     }
     
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C010] Total violations found: ${violations.length}`);
+    }
+    
     return violations;
   }
 
-  async analyzeFile(filePath, fileContent, language, config) {
-    const violations = [];
-    
-    // Reset pending blocks for each file
-    this.pendingBlocks = [];
+  async analyzeFile(filePath, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C010] analyzeFile() called for: ${filePath}`);
+    }
     
-    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;
+    // 1. Try Symbol-based analysis first (primary)
+    if (this.config.useSymbolBased && 
+        this.semanticEngine?.project && 
+        this.semanticEngine?.initialized) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C010] Trying symbol-based analysis...`);
         }
-        
-        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
-                ));
-              }
-            }
+        const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+        if (sourceFile) {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`🔧 [C010] Source file found, analyzing with symbol-based...`);
+          }
+          const violations = await this.symbolAnalyzer.analyzeFileWithSymbols(filePath, { ...options, verbose: options.verbose });
+          
+          // Mark violations with analysis strategy
+          violations.forEach(v => v.analysisStrategy = 'symbol-based');
+          
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`✅ [C010] Symbol-based analysis: ${violations.length} violations`);
+          }
+          return violations; // Return even if 0 violations - symbol analysis completed successfully
+        } else {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`⚠️ [C010] Source file not found in project`);
           }
         }
-        
-        // 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] Symbol analysis failed: ${error.message}`);
+        // Continue to fallback
       }
-      
-    } 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 };
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [C010] Symbol analysis conditions check:`);
+        console.log(`  - useSymbolBased: ${this.config.useSymbolBased}`);
+        console.log(`  - semanticEngine: ${!!this.semanticEngine}`);
+        console.log(`  - semanticEngine.project: ${!!this.semanticEngine?.project}`);
+        console.log(`  - semanticEngine.initialized: ${this.semanticEngine?.initialized}`);
+        console.log(`🔄 [C010] Symbol analysis unavailable, using regex fallback`);
       }
     }
     
-    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;
+    // 2. Fallback to regex-based analysis
+    if (this.config.fallbackToRegex) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C010] Trying regex-based analysis...`);
         }
-      } else {
-        // Check for multi-line comment end
-        if (line.substr(pos, 2) === '*/') {
-          inMultiLine = false;
-          pos += 2;
-          continue;
+        const violations = await this.regexAnalyzer.analyzeFileBasic(filePath, options);
+        
+        // Mark violations with analysis strategy
+        violations.forEach(v => v.analysisStrategy = 'regex-fallback');
+        
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔄 [C010] Regex-based analysis: ${violations.length} violations`);
         }
+        return violations;
+      } catch (error) {
+        console.error(`❌ [C010] Regex analysis failed: ${error.message}`);
       }
-      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('*/');
+    if (options?.verbose) {
+      console.log(`🔧 [C010] No analysis methods succeeded, returning empty`);
     }
-    
-    return false;
+    return [];
   }
-  
-  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
-      };
-    }
+
+  async analyzeFileBasic(filePath, options = {}) {
+    console.log(`🔧 [C010] analyzeFileBasic() called for: ${filePath}`);
+    console.log(`🔧 [C010] semanticEngine exists: ${!!this.semanticEngine}`);
+    console.log(`🔧 [C010] symbolAnalyzer exists: ${!!this.symbolAnalyzer}`);
+    console.log(`🔧 [C010] regexAnalyzer exists: ${!!this.regexAnalyzer}`);
     
-    // 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
-          };
+    try {
+      // Try symbol-based analysis first
+      if (this.semanticEngine?.isSymbolEngineReady?.() && 
+          this.semanticEngine.project) {
+        
+        if (this.verbose) {
+          console.log(`🔍 [C010] Using symbol-based analysis for ${filePath}`);
         }
+        
+        const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
+        return violations;
       }
-    }
-    
-    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 };
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [C010] Symbol analysis failed: ${error.message}`);
       }
     }
     
-    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();
+    // Fallback to regex-based analysis
+    if (this.verbose) {
+      console.log(`🔄 [C010] Using regex-based analysis (fallback) for ${filePath}`);
     }
-  }
-  
-  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));
+    console.log(`🔧 [C010] About to call regexAnalyzer.analyzeFileBasic()`);
+    try {
+      const result = await this.regexAnalyzer.analyzeFileBasic(filePath, options);
+      console.log(`🔧 [C010] Regex analyzer returned: ${result.length} violations`);
+      return result;
+    } catch (error) {
+      console.error(`🔧 [C010] Error in regex analyzer:`, error);
+      return [];
+    }
   }
-  
-  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
-      }))
-    };
+
+  /**
+   * Methods for compatibility with different engine invocation patterns
+   */
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
   }
-  
-  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)];
+
+  async analyzeWithSemantics(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
   }
 }
 
-module.exports = C010LimitBlockNestingAnalyzer;
+module.exports = C010Analyzer;

package/rules/common/C010_limit_block_nesting/config.json

@@ -0,0 +1,64 @@
+{
+  "id": "C010_limit_block_nesting",
+  "name": "C010_limit_block_nesting", 
+  "category": "complexity",
+  "description": "C010 - Limit nested blocks (if/for/while/switch/try) to maximum 3 levels for readability",
+  "severity": "warning",
+  "enabled": true,
+  "semantic": {
+    "enabled": true,
+    "priority": "high",
+    "fallback": "heuristic"
+  },
+  "patterns": {
+    "include": [
+      "**/*.js",
+      "**/*.ts",
+      "**/*.jsx", 
+      "**/*.tsx"
+    ],
+    "exclude": [
+      "**/*.test.js",
+      "**/*.test.ts",
+      "**/*.spec.js",
+      "**/*.spec.ts",
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**"
+    ]
+  },
+  "analysis": {
+    "approach": "symbol-based-primary",
+    "fallback": "regex-based",
+    "depth": 3,
+    "timeout": 5000
+  },
+  "nesting": {
+    "maxDepth": 3,
+    "countingStatements": [
+      "IfStatement",
+      "ForStatement", 
+      "ForInStatement",
+      "ForOfStatement",
+      "WhileStatement",
+      "DoStatement",
+      "SwitchStatement",
+      "TryStatement",
+      "CatchClause"
+    ],
+    "ignoredStatements": [
+      "FunctionDeclaration",
+      "MethodDeclaration",
+      "ArrowFunction",
+      "FunctionExpression",
+      "Constructor",
+      "ClassDeclaration",
+      "InterfaceDeclaration"
+    ]
+  },
+  "options": {
+    "ignoreComments": true,
+    "countEmptyBlocks": false,
+    "treatCatchAsBlock": true
+  }
+}