@sun-asterisk/sunlint 1.3.47 → 1.3.49

package/engines/impact/core/utils/method-call-graph.js

@@ -9,8 +9,8 @@ import path from 'path';
 export class MethodCallGraph {
   constructor() {
     this.project = null;
-    this.methodCallMap = new Map(); // method -> [callers] (reverse map)
-    this.methodCallsMap = new Map(); // method -> [methods it calls] (forward map)
+    this.methodCallMap = new Map(); // method -> Set(callers)
+    this.methodCallsMap = new Map(); // method -> Set(methods it calls)
     this.methodToFile = new Map(); // method -> file path
     this.methodToEndpoint = new Map(); // method -> endpoint info
     this.interfaceToClass = new Map(); // interface name -> concrete class name
@@ -19,121 +19,311 @@ export class MethodCallGraph {
     this.queueNameToProcessor = new Map(); // queue name -> processor class name
     this.methodToQueueProcessor = new Map(); // method -> queue processor info
     this.endpointToQueueNames = new Map(); // endpoint method -> [queue names]
+    this.classSet = new Set(); // All class names for O(1) lookup
+    this.typeCache = new Map(); // Cache type resolution results
+    this.dispatchPatterns = new Set(['sendcommand', 'send', 'execute', 'dispatch', 'publish', 'emit', 'trigger', 'enqueue']);
   }
 
   /**
    * Initialize ts-morph project and build call graph
    */
-  async initialize(sourceDir, excludePaths = [], verbose = false) {
+  async initialize(sourceDir, excludePaths = [], verbose = false, gitignoreParser = null) {
     this.verbose = verbose;
+    this.gitignoreParser = gitignoreParser;
     
+    if (this.verbose) {
+      console.log(`\n🔍 Discovering TypeScript files...`);
+    }
+
+    // Step 1: Find files BEFORE creating project (prevents module resolution)
+    const { glob } = await import('glob');
+    const pattern = `${sourceDir}/**/*.ts`;
+    
+    // Build ignore patterns for glob
+    const ignorePatterns = [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/*.d.ts',  // Type definitions have no runtime code
+      ...excludePaths.map(p => `**/*${p}*/**`),  // Convert simple paths to globs
+    ];
+    
+    // Get all matching files
+    const allFiles = glob.sync(pattern, {
+      ignore: ignorePatterns,
+      absolute: true,
+      nodir: true,
+    });
+    
+    // Apply gitignore filtering if available
+    const rootDir = path.join(sourceDir, '..');
+    const filteredFiles = gitignoreParser
+      ? allFiles.filter(filePath => {
+          const relativeToRoot = path.relative(rootDir, filePath);
+          return !gitignoreParser.shouldExclude(relativeToRoot);
+        })
+      : allFiles;
+    
+    if (this.verbose) {
+      console.log(`   Found ${allFiles.length} TypeScript files`);
+      if (gitignoreParser) {
+        console.log(`   Filtered to ${filteredFiles.length} files after gitignore patterns`);
+      }
+      const excludedCount = allFiles.length - filteredFiles.length;
+      if (excludedCount > 0) {
+        console.log(`   Excluded ${excludedCount} files (${Math.round(excludedCount / allFiles.length * 100)}%)`);
+      }
+    }
+
+    // Step 2: Create ts-morph project WITHOUT tsconfig (prevents loading node_modules)
     this.project = new Project({
-      tsConfigFilePath: path.join(sourceDir, '../tsconfig.json'),
       skipAddingFilesFromTsConfig: true,
+      skipLoadingLibFiles: true,
+      compilerOptions: {
+        target: 99, // ESNext
+        module: 1,  // CommonJS
+        skipLibCheck: true,
+        allowJs: false,
+        noResolve: true,  // Critical: Don't resolve module imports
+      }
     });
 
-    // Add source files
-    this.project.addSourceFilesAtPaths(`${sourceDir}/**/*.ts`);
+    // Step 3: Add only the filtered files (no module resolution!)
+    if (this.verbose) {
+      console.log(`\n📊 Loading ${filteredFiles.length} files into ts-morph...`);
+    }
+    
+    this.project.addSourceFilesAtPaths(filteredFiles);
+    
+    const sourceFiles = this.project.getSourceFiles();
 
-    // Filter out excluded paths
-    const sourceFiles = this.project.getSourceFiles().filter(sf => {
-      const filePath = sf.getFilePath();
-      return !excludePaths.some(ex => filePath.includes(ex));
-    });
+    if (this.verbose) {
+      console.log(`   ✅ Loaded ${sourceFiles.length} files`);
+      console.log(`\n🔬 Analyzing source code...`);
+    }
 
+    // Step 4: Single pass analysis
     for (const sourceFile of sourceFiles) {
-      this.extractInterfaceMappings(sourceFile);
-      this.extractCommandMappings(sourceFile);
-      this.extractQueueProcessorMappings(sourceFile);
+      this.analyzeFileComplete(sourceFile);
     }
 
-    for (const sourceFile of sourceFiles) {
-      this.analyzeFile(sourceFile);
+    if (this.verbose) {
+      console.log(`\n✅ Analysis complete!`);
+      console.log(`   Classes found: ${this.classSet.size}`);
+      console.log(`   Methods found: ${this.methodToFile.size}`);
+      console.log(`   Endpoints found: ${this.methodToEndpoint.size}`);
     }
 
     return this;
   }
 
   /**
-   * Analyze a single file to extract method definitions and calls
+   * Analyze a single file - consolidated single pass
    */
-  analyzeFile(sourceFile) {
+  analyzeFileComplete(sourceFile) {
     const filePath = sourceFile.getFilePath();
-
-    // Get all classes
     const classes = sourceFile.getClasses();
 
     for (const classDecl of classes) {
       const className = classDecl.getName();
-      if (!className) continue; // Skip anonymous classes
+      if (!className) continue;
+
+      this.classSet.add(className);
 
-      // Check if this class is a queue processor
+      // Extract class-level metadata
       const classDecorators = classDecl.getDecorators();
+
+      // Check for @Processor decorator
       const processorDecorator = classDecorators.find(d => d.getName() === 'Processor');
       let processorQueueName = null;
-
       if (processorDecorator) {
         const args = processorDecorator.getArguments();
         processorQueueName = args[0]?.getText().replace(/['"]/g, '');
+        this.queueNameToProcessor.set(processorQueueName, className);
       }
 
-      // Get all methods in this class
-      const methods = classDecl.getMethods();
+      // Check for @Command decorator
+      const commandDecorator = classDecorators.find(d => d.getName() === 'Command');
+      if (commandDecorator) {
+        const args = commandDecorator.getArguments();
+        if (args.length > 0) {
+          const text = args[0].getText();
+          const nameMatch = text.match(/name:\s*['"]([^'"]+)['"]/);
+          if (nameMatch) {
+            this.commandNameToClass.set(nameMatch[1], className);
+          }
+        }
+      }
 
+      // Extract interface mappings from @Module decorator
+      const moduleDecorator = classDecl.getDecorator('Module');
+      if (moduleDecorator) {
+        const args = moduleDecorator.getArguments();
+        if (args.length > 0) {
+          const text = args[0].getText();
+          const providerPattern = /\{\s*provide:\s*['"](\w+)['"]\s*,\s*useClass:\s*(\w+)/g;
+          let match;
+          while ((match = providerPattern.exec(text)) !== null) {
+            this.interfaceToClass.set(match[1], match[2]);
+          }
+        }
+      }
+
+      // Analyze methods
+      const methods = classDecl.getMethods();
       for (const method of methods) {
-        const methodName = method.getName();
-        const fullMethodName = `${className}.${methodName}`;
-
-        // Store method location
-        this.methodToFile.set(fullMethodName, filePath);
-
-        // Check if this is an endpoint method (has HTTP decorator)
-        const decorators = method.getDecorators();
-        const httpDecorator = decorators.find(d => 
-          ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Options', 'Head', 'All'].includes(d.getName())
-        );
-
-        if (httpDecorator) {
-          const decoratorName = httpDecorator.getName();
-          const args = httpDecorator.getArguments();
-          const route = args[0]?.getText().replace(/['"]/g, '') || '/';
-
-          this.methodToEndpoint.set(fullMethodName, {
-            method: decoratorName.toUpperCase(),
-            path: route,
-            controller: className,
-            file: filePath,
-          });
+        this.analyzeMethodComplete(method, className, filePath, processorQueueName);
+      }
+    }
+  }
+
+  /**
+   * Analyze a single method - consolidated single AST traversal
+   */
+  analyzeMethodComplete(method, className, filePath, processorQueueName) {
+    const methodName = method.getName();
+    const fullMethodName = `${className}.${methodName}`;
+
+    this.methodToFile.set(fullMethodName, filePath);
+
+    // Check decorators
+    const decorators = method.getDecorators();
+
+    // Check for HTTP endpoint
+    const httpDecorator = decorators.find(d =>
+      ['Get', 'Post', 'Put', 'Delete', 'Patch', 'Options', 'Head', 'All'].includes(d.getName())
+    );
+    if (httpDecorator) {
+      const decoratorName = httpDecorator.getName();
+      const args = httpDecorator.getArguments();
+      const route = args[0]?.getText().replace(/['"]/g, '') || '/';
+      this.methodToEndpoint.set(fullMethodName, {
+        method: decoratorName.toUpperCase(),
+        path: route,
+        controller: className,
+        file: filePath,
+      });
+    }
+
+    // Check for @Process decorator
+    const processDecorator = decorators.find(d => d.getName() === 'Process');
+    if (processDecorator && processorQueueName) {
+      const args = processDecorator.getArguments();
+      const jobName = args[0]?.getText().replace(/['"]/g, '') || '';
+      this.methodToQueueProcessor.set(fullMethodName, {
+        queueName: processorQueueName,
+        jobName: jobName,
+        processor: className,
+        method: methodName,
+        file: filePath,
+      });
+    }
+
+    // Single AST traversal for all call expressions
+    const callExpressions = method.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+    const commandNames = [];
+    const queueNames = [];
+
+    for (const call of callExpressions) {
+      const expression = call.getExpression();
+
+      if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+        const calledMethodName = expression.getName();
+        const objExpression = expression.getExpression();
+
+        // Process method calls
+        const calledClassName = this.resolveClassName(objExpression, className);
+        if (calledClassName) {
+          this.recordMethodCall(fullMethodName, calledClassName, calledMethodName);
         }
 
-        // Check if this is a queue processor method (has @Process decorator)
-        const processDecorator = decorators.find(d => d.getName() === 'Process');
-        if (processDecorator && processorQueueName) {
-          const args = processDecorator.getArguments();
-          const jobName = args[0]?.getText().replace(/['"]/g, '') || '';
-
-          this.methodToQueueProcessor.set(fullMethodName, {
-            queueName: processorQueueName,
-            jobName: jobName,
-            processor: className,
-            method: methodName,
-            file: filePath,
-          });
+        // Process command dispatches
+        if (this.isDispatchMethod(calledMethodName)) {
+          const args = call.getArguments();
+          if (args.length > 0) {
+            const firstArg = args[0];
+            if (firstArg.getKind() === SyntaxKind.StringLiteral) {
+              const commandName = firstArg.getText().replace(/['"]/g, '');
+              commandNames.push(commandName);
+            } else if (firstArg.getKind() === SyntaxKind.ObjectLiteralExpression) {
+              const commandName = this.extractCommandFromObject(firstArg, method);
+              if (commandName) commandNames.push(commandName);
+            }
+          }
+        }
 
-          if (this.verbose) {
-            console.log(`   🔄 Found queue processor: ${processorQueueName}${jobName ? `/${jobName}` : ''} → ${fullMethodName}`);
+        // Process queue dispatches
+        if (calledMethodName === 'add' && objExpression.getKind() === SyntaxKind.PropertyAccessExpression) {
+          const queuePropertyName = objExpression.getName();
+          const classDecl = method.getParent();
+          if (classDecl && classDecl.getKind() === SyntaxKind.ClassDeclaration) {
+            const constructor = classDecl.getConstructors()[0];
+            if (constructor) {
+              const queueName = this.findQueueNameFromConstructor(constructor, queuePropertyName);
+              if (queueName && !queueNames.includes(queueName)) {
+                queueNames.push(queueName);
+              }
+            }
           }
         }
+      }
+    }
 
-        // Find all method calls within this method
-        this.analyzeMethodCalls(method, className, fullMethodName);
+    if (commandNames.length > 0) {
+      this.endpointToCommandNames.set(fullMethodName, commandNames);
+    }
+    if (queueNames.length > 0) {
+      this.endpointToQueueNames.set(fullMethodName, queueNames);
+    }
+  }
+
+  /**
+   * Resolve class name with caching and optimizations
+   */
+  resolveClassName(objExpression, fallbackClassName) {
+    if (objExpression.getKind() === SyntaxKind.ThisKeyword) {
+      return fallbackClassName;
+    }
+
+    const cacheKey = objExpression.getText();
+    if (this.typeCache.has(cacheKey)) {
+      return this.typeCache.get(cacheKey);
+    }
+
+    const type = objExpression.getType();
+    const symbol = type.getSymbol();
+
+    if (!symbol) {
+      this.typeCache.set(cacheKey, null);
+      return null;
+    }
 
-        // Detect command dispatches and queue jobs in ALL methods (not just endpoints)
-        // This allows us to track: Controller → Service → Queue → Processor
-        this.detectCommandDispatches(method, fullMethodName);
-        this.detectQueueDispatches(method, fullMethodName);
+    let calledClassName = symbol.getName();
+
+    if (this.interfaceToClass.has(calledClassName)) {
+      calledClassName = this.interfaceToClass.get(calledClassName);
+    } else if (calledClassName.startsWith('I') && calledClassName.length > 1) {
+      const possibleClassName = calledClassName.substring(1);
+      if (this.classSet.has(possibleClassName)) {
+        calledClassName = possibleClassName;
       }
     }
+
+    this.typeCache.set(cacheKey, calledClassName);
+    return calledClassName;
+  }
+
+  /**
+   * Check if method name matches dispatch patterns
+   */
+  isDispatchMethod(methodName) {
+    const lower = methodName.toLowerCase();
+    if (this.dispatchPatterns.has(lower)) return true;
+    for (const pattern of this.dispatchPatterns) {
+      if (lower.includes(pattern)) return true;
+    }
+    return false;
   }
 
   /**
@@ -458,25 +648,17 @@ export class MethodCallGraph {
   recordMethodCall(callerFullName, calleeClassName, calleeMethodName) {
     const calleeFullName = `${calleeClassName}.${calleeMethodName}`;
 
-    // Add to reverse map (who calls this method)
+    // Add to reverse map (who calls this method) - use Set for O(1)
     if (!this.methodCallMap.has(calleeFullName)) {
-      this.methodCallMap.set(calleeFullName, []);
+      this.methodCallMap.set(calleeFullName, new Set());
     }
+    this.methodCallMap.get(calleeFullName).add(callerFullName);
 
-    const callers = this.methodCallMap.get(calleeFullName);
-    if (!callers.includes(callerFullName)) {
-      callers.push(callerFullName);
-    }
-
-    // Add to forward map (what this method calls)
+    // Add to forward map (what this method calls) - use Set for O(1)
     if (!this.methodCallsMap.has(callerFullName)) {
-      this.methodCallsMap.set(callerFullName, []);
-    }
-
-    const calls = this.methodCallsMap.get(callerFullName);
-    if (!calls.includes(calleeFullName)) {
-      calls.push(calleeFullName);
+      this.methodCallsMap.set(callerFullName, new Set());
     }
+    this.methodCallsMap.get(callerFullName).add(calleeFullName);
   }
 
   /**
@@ -653,17 +835,20 @@ export class MethodCallGraph {
    * Get direct callers of a method
    */
   getCallers(methodName) {
-    return this.methodCallMap.get(methodName) || [];
+    const callers = this.methodCallMap.get(methodName);
+    return callers ? Array.from(callers) : [];
   }
 
   /**
    * Find all callers of a method (recursive)
    */
-  findAllCallers(methodName, visited = new Set(), depth = 0) {
+  findAllCallers(methodName, visited = new Set(), depth = 0, maxDepth = 10) {
     if (visited.has(methodName)) return [];
+    if (depth >= maxDepth) return [];
 
     visited.add(methodName);
-    const directCallers = this.methodCallMap.get(methodName) || [];
+    const directCallersSet = this.methodCallMap.get(methodName);
+    const directCallers = directCallersSet ? Array.from(directCallersSet) : [];
     let allCallers = [...directCallers];
 
     if (this.verbose && depth === 0) {
@@ -676,7 +861,7 @@ export class MethodCallGraph {
       if (this.verbose && depth === 0) {
         console.log(`      Tracing up from: ${caller}`);
       }
-      const indirectCallers = this.findAllCallers(caller, visited, depth + 1);
+      const indirectCallers = this.findAllCallers(caller, visited, depth + 1, maxDepth);
       allCallers = allCallers.concat(indirectCallers);
     }
 

package/origin-rules/dart-en.md

@@ -82,7 +82,7 @@
 ### 📘 Rule D008 – Avoid Long Functions
 
 - **Objective**: Improve code readability and maintainability by limiting function length
-- **Details**: Functions should not exceed 60 lines of effective code (excluding comments and opening/closing braces). Long functions are harder to understand, test, and maintain. They often indicate that the function is doing too much and should be broken down into smaller, more focused functions. The line count excludes blank lines, comments (both single-line // and multi-line /* */), and the opening { and closing } braces. The maximum line limit is configurable.
+- **Details**: Functions should not exceed 60 lines of effective code (excluding comments and opening/closing braces). Long functions are harder to understand, test, and maintain. They often indicate that the function is doing too much and should be broken down into smaller, more focused functions. The line count excludes blank lines, comments (both single-line // and multi-line /\* \*/), and the opening `{` and closing `}` braces. The maximum line limit is configurable.
 - **Applies to**: Flutter/Dart
 - **Tools**: Custom analyzer (D008)
 - **Principles**: CODE_QUALITY, MAINTAINABILITY, READABILITY