@sun-asterisk/sunlint 1.3.18 → 1.3.20

package/rules/common/C017_constructor_logic/analyzer.js

@@ -1,551 +1,185 @@
-const fs = require('fs');
-const path = require('path');
+/**
+ * C017 Main Analyzer - Do not put business logic inside constructors
+ * Primary: Ensure constructors only initialize objects, not perform business logic, to improve testability.
+ * Fallback: Regex-based for all other cases
+ * node cli.js --rules=c017 --input=examples/rule-test-fixtures/rules/C017_constructor_logic/violations  --engine=heuristic --verbose
+ */
+
+const C017SymbolBasedAnalyzer = require('./symbol-based-analyzer');
 
 class C017Analyzer {
-  constructor() {
+  constructor(options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C017] Constructor called with options:`, !!options);
+      console.log(`🔧 [C017] Options type:`, typeof options, Object.keys(options || {}));
+    }
+
     this.ruleId = 'C017';
-    this.ruleName = 'Constructor Logic Limitation';
-    this.description = 'Không gán logic xử lý vào constructor';
-  }
+    this.ruleName = 'Do not put business logic inside constructors';
+    this.description = 'Ensure constructors only initialize objects, not perform business logic, to improve testability.';
+    this.semanticEngine = options.semanticEngine || null;
+    this.verbose = options.verbose || false;
+
+    // Configuration
+    this.config = {
+      useSymbolBased: true,      // Primary approach
+      fallbackToRegex: false,     // Only when symbol fails completely
+      symbolBasedOnly: false     // Can be set to true for pure mode
+    };
 
-  async analyze(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🔍 Running C017 analysis on ${path.basename(filePath)}`);
-      }
-      
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, content, language, options);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`⚠️ Failed to analyze ${filePath}: ${error.message}`);
+    // Initialize both analyzers
+    try {
+      this.symbolAnalyzer = new C017SymbolBasedAnalyzer(this.semanticEngine);
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔧 [C017] Symbol analyzer created successfully`);
       }
+    } catch (error) {
+      console.error(`🔧 [C017] Error creating symbol analyzer:`, error);
     }
-    
-    return violations;
-  }
 
-  async analyzeFile(filePath, content, language, config) {
-    switch (language) {
-      case 'typescript':
-      case 'javascript':
-        return this.analyzeTypeScript(filePath, content, config);
-      default:
-        return [];
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C017] Constructor completed`);
     }
   }
 
-  async analyzeTypeScript(filePath, content, config) {
-    const violations = [];
-    const lines = content.split('\n');
-    
-    // Find constructor blocks and analyze their content
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      // Detect constructor start
-      if (this.isConstructorStart(trimmedLine)) {
-        const constructorInfo = this.extractConstructorInfo(lines, index);
-        
-        // Debug logging to understand boundary detection
-        if (config?.verbose) {
-          console.log(`[DEBUG] Constructor found at line ${lineNumber}`);
-          console.log(`[DEBUG] Constructor body lines: ${constructorInfo.body.length}`);
-          console.log(`[DEBUG] Constructor content:`, constructorInfo.body.map((l, i) => `${lineNumber + i}: ${l}`));
-        }
-        
-        const complexLogic = this.findComplexLogic(constructorInfo.body);
-        
-        complexLogic.forEach(logic => {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber + logic.lineOffset,
-            column: logic.column,
-            message: `Constructor contains complex logic: ${logic.description}. Move to initialization methods`,
-            severity: 'warning',
-            code: logic.code,
-            type: logic.type,
-            confidence: logic.confidence,
-            suggestion: 'Move complex logic to separate initialization methods or lifecycle hooks'
-          });
-        });
-      }
-    });
-
-    return violations;
-  }
+  /**
+   * Initialize with semantic engine
+   */
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
+    }
+    this.verbose = semanticEngine?.verbose || false;
 
-  isConstructorStart(line) {
-    return line.includes('constructor(') || line.match(/constructor\s*\(/);
-  }
+    // Initialize both analyzers
+    await this.symbolAnalyzer.initialize(semanticEngine);
 
-  extractConstructorInfo(lines, startIndex) {
-    const constructorLines = [];
-    let braceDepth = 0;
-    let foundConstructorBrace = false;
-    let inConstructor = false;
-    let parenthesesDepth = 0;
-    let inCallback = false;
+    // Ensure verbose flag is propagated
+    this.symbolAnalyzer.verbose = this.verbose;
 
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmedLine = line.trim();
-      
-      // Check if this is the constructor line with opening brace
-      if (this.isConstructorStart(trimmedLine)) {
-        inConstructor = true;
-        constructorLines.push(line);
-        
-        // Special case: empty constructor () {}
-        if (trimmedLine.includes(') {}')) {
-          foundConstructorBrace = true;
-          braceDepth = 0; // Already closed
-          break; // Stop immediately for empty constructor
-        }
-        
-        // Count braces and parentheses in the constructor line itself
-        for (const char of line) {
-          if (char === '{') {
-            foundConstructorBrace = true;
-            braceDepth = 1; // Start counting from 1 for the constructor block
-          } else if (char === '(') {
-            parenthesesDepth++;
-          } else if (char === ')') {
-            parenthesesDepth--;
-          }
-        }
-      } else if (inConstructor && foundConstructorBrace) {
-        constructorLines.push(line);
-        
-        // Track callback functions and nested structures
-        for (const char of line) {
-          if (char === '(') {
-            parenthesesDepth++;
-            // Detect callback patterns: .use(, .then(, .catch(, etc.
-            if (line.includes('.use(') || line.includes('.then(') || 
-                line.includes('.catch(') || line.includes('.finally(') ||
-                line.includes('=>')) {
-              inCallback = true;
-            }
-          } else if (char === ')') {
-            parenthesesDepth--;
-            if (parenthesesDepth <= 0) {
-              inCallback = false;
-            }
-          } else if (char === '{') {
-            braceDepth++;
-          } else if (char === '}') {
-            braceDepth--;
-          }
-        }
-        
-        // If we've closed all braces and not in callback, we're done
-        if (braceDepth === 0 && !inCallback) {
-          break;
-        }
-      } else if (inConstructor) {
-        // Haven't found the opening brace yet, keep looking
-        constructorLines.push(line);
-        
-        // Check for empty constructor pattern: ) {}
-        if (trimmedLine.includes(') {}')) {
-          foundConstructorBrace = true;
-          braceDepth = 0; // Already closed
-          break; // Stop immediately
-        }
-        
-        for (const char of line) {
-          if (char === '{') {
-            foundConstructorBrace = true;
-            braceDepth = 1;
-            break;
-          }
-        }
-      }
-        }
-        
-        for (const char of line) {
-          if (char === '{') {
-            foundConstructorBrace = true;
-            braceDepth = 1;
-            break;
-          }
-        }
-      }
+    if (this.verbose) {
+      console.log(`🔧 [C017 Hybrid] Analyzer initialized - verbose: ${this.verbose}`);
     }
-
-    return {
-      body: constructorLines,
-      startLine: startIndex
-    };
   }
 
-  findComplexLogic(constructorBody) {
-    const complexLogic = [];
-    let inCallbackFunction = false;
-    let callbackDepth = 0;
-    
-    // Check if this is an empty constructor first
-    // TEMPORARILY DISABLED for debugging
-    // if (this.isEmptyConstructor(constructorBody)) {
-    //   return complexLogic; // Return empty array - no violations for empty constructors
-    // }
-    
-    constructorBody.forEach((line, index) => {
-      const trimmedLine = line.trim();
-      
-      // Skip comments, empty lines, and constructor declaration
-      if (!trimmedLine || 
-          trimmedLine.startsWith('//') || 
-          trimmedLine.startsWith('/*') ||
-          trimmedLine.startsWith('*') ||
-          this.isConstructorStart(trimmedLine) ||
-          trimmedLine === '{' ||
-          trimmedLine === '}') {
-        return;
-      }
+  async analyze(files, language, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C017] analyze() method called with ${files.length} files, language: ${language}`);
+    }
 
-      // Track callback functions to avoid flagging their content
-      if (this.isCallbackStart(trimmedLine)) {
-        inCallbackFunction = true;
-        callbackDepth = 1;
-        return;
-      }
+    const violations = [];
 
-      if (inCallbackFunction) {
-        // Count braces to track callback boundaries
-        const openBraces = (trimmedLine.match(/\{/g) || []).length;
-        const closeBraces = (trimmedLine.match(/\}/g) || []).length;
-        callbackDepth += openBraces - closeBraces;
-        
-        if (callbackDepth <= 0) {
-          inCallbackFunction = false;
-          callbackDepth = 0;
+    for (const filePath of files) {
+      try {
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C017] Processing file: ${filePath}`);
         }
-        return; // Skip analysis inside callbacks
-      }
-
-      // Analyze line for complex logic patterns only if not in callback
-      const logicType = this.analyzeLineComplexity(trimmedLine);
-      
-      if (logicType) {
-        complexLogic.push({
-          lineOffset: index,
-          column: line.indexOf(trimmedLine) + 1,
-          code: trimmedLine,
-          type: logicType.type,
-          description: logicType.description,
-          confidence: logicType.confidence
-        });
-      }
-    });
 
-    return complexLogic;
-  }
+        const fileViolations = await this.analyzeFile(filePath, options);
+        violations.push(...fileViolations);
 
-  isEmptyConstructor(constructorBody) {
-    // Check if constructor body contains only dependency injection parameters and closing brace
-    const meaningfulLines = constructorBody.filter(line => {
-      const trimmed = line.trim();
-      
-      // Skip empty lines, comments, and constructor declaration
-      if (!trimmed || 
-          trimmed.startsWith('//') || 
-          trimmed.startsWith('/*') || 
-          trimmed.startsWith('*') ||
-          this.isConstructorStart(trimmed) ||
-          trimmed === '{' || 
-          trimmed === '}' ||
-          trimmed === ') {}') {
-        return false;
-      }
-      
-      // Skip constructor parameter declarations (NestJS style)
-      if (trimmed.startsWith('@') || // Decorators like @InjectRepository
-          trimmed.match(/^\s*(private|public|protected)\s+readonly\s+\w+/) || // DI parameters
-          trimmed.match(/^\s*(private|public|protected)\s+\w+/) || // Other parameters
-          trimmed.endsWith(',') || // Parameter continuation
-          trimmed.endsWith(') {')) { // Constructor parameter closing
-        return false;
+        if (process.env.SUNLINT_DEBUG) {
+          console.log(`🔧 [C017] File ${filePath}: Found ${fileViolations.length} violations`);
+        }
+      } catch (error) {
+        console.warn(`❌ [C017] Analysis failed for ${filePath}:`, error.message);
       }
-      
-      // This is a meaningful line (logic, assignments, calls, etc.)
-      return true;
-    });
-    
-    return meaningfulLines.length === 0;
-  }
-
-  isCallbackStart(line) {
-    // Patterns that indicate callback function starts
-    const callbackPatterns = [
-      /\.(use|then|catch|finally|map|filter|forEach|reduce)\s*\(/,
-      /=>\s*\{/,
-      /function\s*\(/,
-      /\(\s*\w+\s*\)\s*=>/,
-      /interceptors\.(request|response)\.use\(/,
-      /\.addEventListener\(/,
-      /setTimeout\(/,
-      /setInterval\(/
-    ];
-
-    return callbackPatterns.some(pattern => pattern.test(line));
-  }
-
-  analyzeLineComplexity(line) {
-    // Simple property assignments are OK
-    if (this.isSimpleAssignment(line)) {
-      return null;
-    }
-
-    // Super calls are OK
-    if (this.isSuperCall(line)) {
-      return null;
     }
 
-    // Parameter assignments are OK
-    if (this.isParameterAssignment(line)) {
-      return null;
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C017] Total violations found: ${violations.length}`);
     }
 
-    // MobX decorators/observables setup are OK
-    if (this.isMobXSetup(line)) {
-      return null;
-    }
+    return violations;
+  }
 
-    // Allowed method calls are OK
-    if (this.isAllowedMethodCall(line)) {
-      return null;
+  async analyzeFile(filePath, options = {}) {
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [C017] analyzeFile() called for: ${filePath}`);
     }
 
-    // Configuration setup is OK
-    if (this.isConfigurationSetup(line)) {
-      return null;
-    }
+    // 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(`🔧 [C017] Trying symbol-based analysis...`);
+        }
+        const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
+        if (sourceFile) {
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`🔧 [C017] Source file found, analyzing with symbol-based...`);
+          }
+          const violations = await this.symbolAnalyzer.analyzeFileWithSymbols(filePath, { ...options, verbose: options.verbose });
 
-    // Interceptor setup is OK (axios, etc.)
-    if (this.isInterceptorSetup(line)) {
-      return null;
-    }
+          // Mark violations with analysis strategy
+          violations.forEach(v => v.analysisStrategy = 'symbol-based');
 
-    // Detect complex logic patterns
-    const complexPatterns = [
-      {
-        pattern: /\bif\s*\(|\belse\s|\bswitch\s*\(/,
-        type: 'conditional_logic',
-        description: 'conditional statements (if/else/switch)',
-        confidence: 0.9
-      },
-      {
-        pattern: /\bfor\s*\(|\bwhile\s*\(|\bdo\s+/,
-        type: 'loop_logic',
-        description: 'loops (for/while)',
-        confidence: 0.95
-      },
-      {
-        pattern: /\btry\s*{|\bcatch\s*\(|\bfinally\s*{/,
-        type: 'exception_handling',
-        description: 'exception handling (try/catch/finally)',
-        confidence: 0.8
-      },
-      {
-        pattern: /\.then\s*\(|\.catch\s*\(|await\s+/,
-        type: 'async_logic',
-        description: 'asynchronous operations',
-        confidence: 0.9
-      },
-      {
-        pattern: /\w+\s*\(\s*[^)]*\)\s*[;{]/,
-        type: 'method_call',
-        description: 'complex method calls',
-        confidence: 0.4 // Reduced confidence to minimize false positives
-      },
-      {
-        pattern: /new\s+\w+\s*\([^)]*\)\s*\./,
-        type: 'chained_instantiation',
-        description: 'chained object instantiation',
-        confidence: 0.8
+          if (process.env.SUNLINT_DEBUG) {
+            console.log(`✅ [C017] 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(`⚠️ [C017] Source file not found in project`);
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ [C017] Symbol analysis failed: ${error.message}`);
+        // Continue to fallback
       }
-    ];
-
-    for (const { pattern, type, description, confidence } of complexPatterns) {
-      if (pattern.test(line)) {
-        return { type, description, confidence };
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [C017] 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(`🔄 [C017] Symbol analysis unavailable, using regex fallback`);
       }
     }
 
-    // Check for complex expressions
-    if (this.hasComplexExpression(line)) {
-      return {
-        type: 'complex_expression',
-        description: 'complex expression or calculation',
-        confidence: 0.6
-      };
+    if (options?.verbose) {
+      console.log(`🔧 [C017] No analysis methods succeeded, returning empty`);
     }
-
-    return null;
+    return [];
   }
 
-  isSimpleAssignment(line) {
-    // Patterns for simple assignments - expanded to catch more legitimate patterns
-    const simplePatterns = [
-      /^this\.\w+\s*=\s*[^;]+;?$/,          // this.property = value;
-      /^this\.\w+\s*=\s*\w+;?$/,            // this.property = parameter;
-      /^this\.\w+\s*=\s*(null|undefined|true|false|\d+|'[^']*'|"[^"]*");?$/, // this.property = literal;
-      /^this\.\w+\s*=\s*this\.\w+\s*\.\s*get\s*\(/,  // this.property = this.configService.get(
-      /^this\.\w+\s*=\s*new\s+\w+\s*\(/,             // this.property = new SomeClass(
-      /^this\.\w+\s*=\s*\w+\s*\.\s*\w+\s*\(/,       // this.property = service.method(
-      // Enhanced patterns for configuration initialization
-      /^this\.\w+\s*=\s*new\s+\w+Client\s*\(/,       // this.s3 = new S3Client(
-      /^this\.\w+\s*=\s*new\s+\w+\s*\(\s*\{/,        // this.prop = new Class({ config })
-      /^this\.\w+\s*=\s*\w+\s*\.\s*create\s*\(/,     // this.prop = Factory.create(
-      /^this\.\w+\s*=\s*\w+\s*\.\s*getInstance\s*\(/, // this.prop = Service.getInstance(
-    ];
+  async analyzeFileBasic(filePath, options = {}) {
+    console.log(`🔧 [C017] analyzeFileBasic() called for: ${filePath}`);
+    console.log(`🔧 [C017] semanticEngine exists: ${!!this.semanticEngine}`);
+    console.log(`🔧 [C017] symbolAnalyzer exists: ${!!this.symbolAnalyzer}`);
 
-    return simplePatterns.some(pattern => pattern.test(line));
-  }
-
-  isConfigurationSetup(line) {
-    // Check if this is configuration/options object setup
-    const configPatterns = [
-      /^\s*\w+:\s*/, // Property definition in object literal
-      /level:\s*/, // Log level setting
-      /timestamp:\s*/, // Timestamp configuration
-      /formatters:\s*/, // Formatter configuration
-      /mixin:\s*/, // Mixin configuration
-      /transport:\s*/, // Transport configuration
-      /options:\s*/, // Options configuration
-      /target:\s*/, // Target configuration
-      /baseURL:\s*/, // Axios baseURL
-      /timeout:\s*/, // Axios timeout
-      /region:\s*/, // AWS region configuration
-      /credentials:\s*/, // AWS credentials
-      /endpoint:\s*/, // API endpoint
-      /apiVersion:\s*/, // API version
-      /maxRetries:\s*/, // Retry configuration  
-      /headers:\s*/, // HTTP headers
-      /defaultHeaders:\s*/, // Default headers
-      /interceptors:\s*/, // Request/response interceptors
-      /transformRequest:\s*/, // Request transformation
-      /transformResponse:\s*/, // Response transformation
-      /validateStatus:\s*/, // Status validation
-      /responseType:\s*/, // Response type
-      /maxContentLength:\s*/, // Content length limit
-      /ssl:\s*/, // SSL configuration
-      /auth:\s*/, // Authentication
-      /withCredentials:\s*/, // CORS credentials
-      /maxRedirects:\s*/, // Max redirects
-    ];
-
-    return configPatterns.some(pattern => pattern.test(line));
-  }
-
-  isInterceptorSetup(line) {
-    // Check if this is axios interceptor setup (should be allowed in constructor)
-    const interceptorPatterns = [
-      /interceptors\.(request|response)\.use/,
-      /\.use\s*\(/,
-      /\.then\s*\(/,
-      /\.catch\s*\(/,
-      /\.finally\s*\(/,
-      /=>\s*\{?/,
-      /=>\s*[^{]/, // Arrow function without braces
-      /function\s*\(/
-    ];
+    try {
+      // Try symbol-based analysis first
+      if (this.semanticEngine?.isSymbolEngineReady?.() &&
+          this.semanticEngine.project) {
 
-    return interceptorPatterns.some(pattern => pattern.test(line));
-  }
-
-  isSuperCall(line) {
-    return line.includes('super(') || line.startsWith('super.');
-  }
-
-  isParameterAssignment(line) {
-    // Check if it's just assigning constructor parameters to properties
-    return /^this\.\w+\s*=\s*\w+;?$/.test(line);
-  }
-
-  isMobXSetup(line) {
-    // MobX patterns that are OK in constructor
-    const mobxPatterns = [
-      'makeObservable',
-      'makeAutoObservable',
-      'observable',
-      'action',
-      'computed',
-      'reaction',
-      'autorun',
-      '@observable',
-      '@action',
-      '@computed'
-    ];
+        if (this.verbose) {
+          console.log(`🔍 [C017] Using symbol-based analysis for ${filePath}`);
+        }
 
-    const lowerLine = line.toLowerCase();
-    return mobxPatterns.some(pattern => 
-      lowerLine.includes(pattern.toLowerCase())
-    );
+        const violations = await this.symbolAnalyzer.analyzeFileBasic(filePath, options);
+        return violations;
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.warn(`⚠️ [C017] Symbol analysis failed: ${error.message}`);
+      }
+    }
   }
 
-  isAllowedMethodCall(line) {
-    // Method calls that are typically OK in constructors - expanded list
-    const allowedMethods = [
-      'makeObservable',
-      'makeAutoObservable',
-      'bind',
-      'addEventListener',
-      'removeEventListener',
-      'Object.assign',
-      'Object.defineProperty',
-      'console.log',
-      'console.warn',
-      // Common initialization patterns
-      'createLogger',
-      'initializeLogger',
-      'setupConfiguration',
-      'initializeService',
-      'configure',
-      'init',
-      'setup',
-      // Common service/config patterns
-      'get',
-      'getService',
-      'getInstance',
-      // Dependency injection patterns
-      'inject',
-      'resolve',
-      // Axios/HTTP setup patterns
-      'interceptors',
-      'use',
-      'defaults',
-      'timeout',
-      'baseURL',
-      'headers'
-    ];
-
-    const lowerLine = line.toLowerCase();
-    return allowedMethods.some(method => 
-      lowerLine.includes(method.toLowerCase())
-    );
+  /**
+   * Methods for compatibility with different engine invocation patterns
+   */
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
   }
 
-  hasComplexExpression(line) {
-    // Check for complex expressions (multiple operators, complex calculations)
-    // Made more restrictive to reduce false positives
-    const complexityIndicators = [
-      /[+\-*/]\s*[+\-*/]/,    // Multiple arithmetic operators
-      /\?\s*.*\s*:/,          // Ternary operators
-      /&&.*&&|\|\|.*\|\|/,    // Multiple logical operators (more restrictive)
-      /\[[^\]]*\].*\[[^\]]*\]/, // Multiple array accesses
-      /\.[^.]*\.[^.]*\./      // Triple+ chained property access (more restrictive)
-    ];
-
-    return complexityIndicators.some(pattern => pattern.test(line));
+  async analyzeWithSemantics(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
   }
 }
 
-module.exports = new C017Analyzer();
+module.exports = C017Analyzer;