@sun-asterisk/sunlint 1.3.1 → 1.3.2

package/rules/common/C003_no_vague_abbreviations/analyzer.js

@@ -1,8 +1,15 @@
 /**
- * C003 Heuristic Analyzer: No vague abbreviations
- * Detects unclear variable names and abbreviations
+ * C003_no_vague_abbreviations - Enhanced Regex-based Rule Analyzer
+ * Category: coding
+ * 
+ * Detects vague variable names and unclear abbreviations
+ * Uses enhanced regex patterns with proper comment filtering
  */
 
+const fs = require('fs');
+const path = require('path');
+const { CommentDetector } = require('../../utils/rule-helpers');
+
 class C003NoVagueAbbreviations {
   constructor(options = {}) {
     this.options = {
@@ -84,19 +91,43 @@ class C003NoVagueAbbreviations {
   }
 
   /**
-   * Check if variable is in math/algorithm context
+   * Check if variable is a generic type parameter
    */
-  isMathContext(content, variableName, line) {
+  isGenericTypeParameter(content, variableName, line) {
+    // Single uppercase letters T, U, V, K, etc. are common generic type names
+    if (!/^[T-Z]$/i.test(variableName)) {
+      return false;
+    }
+    
     const lines = content.split('\n');
     const currentLine = lines[line - 1] || '';
+    const prevLine = lines[line - 2] || '';
+    const nextLine = lines[line] || '';
     
-    // Math constants like a, b, c in equations
-    if (/const\s+[a-z]\s*=\s*\d+.*[a-z]\s*=\s*\d+/.test(currentLine)) {
-      return true;
-    }
+    const contextLines = [prevLine, currentLine, nextLine].join(' ');
     
-    // Math operations
-    if (/[+\-*/=]\s*\w+|\w+\s*[+\-*/=]/.test(currentLine)) {
+    // Check for generic type context
+    const genericPatterns = [
+      /function\s*<[^>]*>/i,           // function<T, U>
+      /class\s+\w+\s*<[^>]*>/i,       // class Foo<T>
+      /interface\s+\w+\s*<[^>]*>/i,   // interface Bar<T>
+      /type\s+\w+\s*<[^>]*>/i,        // type Baz<T>
+      /<[^>]*>.*=>/i,                 // <T>(param: T) =>
+      /:\s*[T-Z]\s*[,)]/i             // parameter: T,
+    ];
+    
+    return genericPatterns.some(pattern => pattern.test(contextLines));
+  }
+
+  /**
+   * Check if variable is a TypeScript type annotation context
+   */
+  isTypeAnnotationContext(content, variableName, line) {
+    const lines = content.split('\n');
+    const currentLine = lines[line - 1] || '';
+    
+    // Check if variable is in type position: param: Type, variable: Type
+    if (/:\s*\w+\s*[,)=]/.test(currentLine)) {
       return true;
     }
     
@@ -104,20 +135,44 @@ class C003NoVagueAbbreviations {
   }
 
   /**
-   * Check if variable is in function parameter context
+   * Check if variable is function parameter context
    */
   isFunctionParameter(content, variableName, line) {
     const lines = content.split('\n');
     const currentLine = lines[line - 1] || '';
     
     // Check if we're in a function parameter list
-    return /function.*\(.*\w+.*\)/.test(currentLine) || 
-           /\(.*\w+.*\)\s*=>/.test(currentLine) ||
-           /\w+\s*=>\s*/.test(currentLine);
+    const functionPatterns = [
+      /function.*\(.*\w+.*\)/,           // function foo(param)
+      /\(.*\w+.*\)\s*=>/,               // (param) => 
+      /\w+\s*=>\s*/,                    // param =>
+      /\w+\s*:\s*\w+\s*[,)]/,          // param: Type,
+      /\w+\?\s*:\s*\w+\s*[,)]/         // param?: Type,
+    ];
+    
+    return functionPatterns.some(pattern => pattern.test(currentLine));
+  }
+
+  /**
+   * Check if variable has clear type information
+   */
+  hasTypeInformation(content, variableName, line) {
+    const lines = content.split('\n');
+    const currentLine = lines[line - 1] || '';
+    
+    // TypeScript type annotations make variables clearer
+    // Example: function process(u: User) - 'u' is clear from User type
+    const typePatterns = [
+      new RegExp(`${variableName}\\s*:\\s*[A-Z]\\w+`),  // param: TypeName
+      new RegExp(`${variableName}\\s*:\\s*\\w+\\[\\]`), // param: Type[]
+      new RegExp(`${variableName}\\s*:\\s*string|number|boolean`) // primitive types
+    ];
+    
+    return typePatterns.some(pattern => pattern.test(currentLine));
   }
 
   /**
-   * Check if variable is coordinate-like
+   * Check if variable is coordinate-like or math notation
    */
   isCoordinate(variableName) {
     return /^[xyz](\d+)?$/i.test(variableName) || 
@@ -126,36 +181,62 @@ class C003NoVagueAbbreviations {
   }
 
   /**
-   * Check if variable is in math/algorithm context
+   * Check if variable is math/algorithm context
    */
   isMathContext(content, variableName, line) {
     const lines = content.split('\n');
     const currentLine = lines[line - 1] || '';
+    const prevLine = lines[line - 2] || '';
+    const nextLine = lines[line] || '';
     
-    // Math constants like a, b, c in equations
-    if (/const\s+[a-z]\s*=\s*\d+.*[a-z]\s*=\s*\d+/.test(currentLine)) {
+    // Check for math variable patterns
+    const mathPatterns = [
+      // Coordinate pairs: x1, y1, x2, y2
+      /^[xyz][12]$/i,
+      // Delta notation: dx, dy, dt, dr
+      /^d[xyztr]$/i,
+      // Math constants: a, b, c in equations
+      /^[abc]$/i,
+      // Vector components: vx, vy, vz
+      /^v[xyz]$/i,
+      // Position/point notation: p1, p2
+      /^p\d+$/i
+    ];
+    
+    if (mathPatterns.some(pattern => pattern.test(variableName))) {
       return true;
     }
     
-    // Math operations
+    // Context-based detection
+    const contextLines = [prevLine, currentLine, nextLine].join(' ');
+    
+    // Check for math function names in the context
+    if (/function\s+(distance|calculate|compute|solve|formula|algorithm|equation|math)/i.test(contextLines)) {
+      return true;
+    }
+    
+    // Math operations context
     if (/[+\-*/=]\s*\w+|\w+\s*[+\-*/=]/.test(currentLine)) {
       return true;
     }
     
-    return false;
-  }
-
-  /**
-   * Check if variable is in function parameter context
-   */
-  isFunctionParameter(content, variableName, line) {
-    const lines = content.split('\n');
-    const currentLine = lines[line - 1] || '';
+    // Math functions context
+    if (/Math\.|sqrt|pow|abs|sin|cos|tan|distance|calculate/i.test(contextLines)) {
+      return true;
+    }
     
-    // Check if we're in a function parameter list
-    return /function.*\(.*\w+.*\)/.test(currentLine) || 
-           /\(.*\w+.*\)\s*=>/.test(currentLine) ||
-           /\w+\s*=>\s*/.test(currentLine);
+    // Multiple single-char variables (typical in math)
+    if (/const\s+[a-z]\s*=.*[a-z]\s*=/.test(currentLine)) {
+      return true;
+    }
+    
+    // Check for function parameters that are clearly coordinates/math
+    // Example: function distance(x1: number, y1: number, x2: number, y2: number)
+    if (/function.*\([^)]*\b(x1|y1|x2|y2|dx|dy|dz|dt)\b.*\)/.test(contextLines)) {
+      return true;
+    }
+    
+    return false;
   }
 
   /**
@@ -244,6 +325,91 @@ class C003NoVagueAbbreviations {
     return violations;
   }
 
+  /**
+   * Clean line by removing comments but preserving structure for regex matching
+   * @param {string} line - Original line
+   * @returns {object} { cleanLine, commentRanges }
+   */
+  cleanLineForMatching(line) {
+    return CommentDetector.cleanLineForMatching(line);
+  }
+
+  /**
+   * Check if a variable at a specific position is inside a comment
+   * @param {string} line - Line content
+   * @param {number} position - Position in line where variable was found
+   * @returns {boolean} True if position is inside a comment
+   */
+  isPositionInComment(line, position) {
+    return CommentDetector.isPositionInComment(line, position);
+  }
+
+  /**
+   * Check if a line is a comment or inside a comment block
+   * @param {string} line - Line to check
+   * @param {number} lineIndex - Current line index
+   * @param {string[]} allLines - All lines in content
+   * @returns {boolean} True if line is commented
+   */
+  isCommentedLine(line, lineIndex, allLines) {
+    const trimmedLine = line.trim();
+    
+    // Check single-line comments
+    if (trimmedLine.startsWith('//') || trimmedLine.startsWith('#')) {
+      return true;
+    }
+    
+    // Check if we're inside a multi-line comment
+    let inComment = false;
+    for (let i = 0; i <= lineIndex; i++) {
+      const currentLine = allLines[i];
+      
+      // Find /* and */ on the same line or across lines
+      let startPos = 0;
+      while (startPos < currentLine.length) {
+        const commentStart = currentLine.indexOf('/*', startPos);
+        const commentEnd = currentLine.indexOf('*/', startPos);
+        
+        if (commentStart !== -1 && (commentEnd === -1 || commentStart < commentEnd)) {
+          inComment = true;
+          startPos = commentStart + 2;
+        } else if (commentEnd !== -1 && inComment) {
+          inComment = false;
+          startPos = commentEnd + 2;
+        } else {
+          break;
+        }
+      }
+      
+      // If we're at the target line and inside a comment
+      if (i === lineIndex && inComment) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * Remove comments from content
+   * @param {string} content - File content
+   * @returns {string} Content with comments removed
+   */
+  removeComments(content) {
+    let result = content;
+    
+    // Remove single line comments (// comments)
+    result = result.replace(/\/\/.*$/gm, '');
+    
+    // Remove multi-line comments (/* comments */)
+    result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+    
+    // Remove # comments (for other languages like Python, Shell)
+    result = result.replace(/#.*$/gm, '');
+    
+    return result;
+  }
+
   /**
    * Analyze variable names in content
    */
@@ -255,12 +421,25 @@ class C003NoVagueAbbreviations {
     }
 
     const violations = [];
-    const lines = content.split('\n');
+    const lines = content.split('\n'); // Use original content to preserve line numbers
     
     lines.forEach((line, index) => {
       const lineNumber = index + 1;
       
-      // Match variable declarations
+      // Skip commented lines
+      if (this.isCommentedLine(line, index, lines)) {
+        return;
+      }
+      
+      // Skip empty lines
+      if (!line.trim()) {
+        return;
+      }
+      
+      // Clean line for better pattern matching
+      const { cleanLine } = this.cleanLineForMatching(line);
+      
+      // Match variable declarations on cleaned line
       const patterns = [
         // const/let/var declarations
         /(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[=:]/g,
@@ -274,7 +453,7 @@ class C003NoVagueAbbreviations {
       
       patterns.forEach(pattern => {
         let match;
-        while ((match = pattern.exec(line)) !== null) {
+        while ((match = pattern.exec(cleanLine)) !== null) {
           let variableNames = [];
           
           if (match[1]) {
@@ -292,6 +471,7 @@ class C003NoVagueAbbreviations {
           }
           
           variableNames.forEach(variableName => {
+            // No need to check position since we're using cleaned line
             const violation = this.checkVariableName(variableName, content, lineNumber, match.index);
             if (violation) {
               violations.push({
@@ -395,6 +575,11 @@ class C003NoVagueAbbreviations {
       };
     }
 
+    // Check for math context BEFORE suspicious patterns
+    if (this.isMathContext(content, variableName, line)) {
+      return null;
+    }
+
     // Check for suspicious patterns
     for (const pattern of this.suspiciousPatterns) {
       if (pattern.test(lowerName)) {

package/rules/common/C006_function_naming/analyzer.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const ts = require('typescript');
+const { CommentDetector } = require('../../utils/rule-helpers');
 
 /**
  * SMART C006 ANALYZER - INTELLIGENT FUNCTION NAMING ANALYSIS
@@ -254,6 +255,20 @@ class SmartC006Analyzer {
    * Uses multiple strategies to detect verbs
    */
   isVerbLikeName(functionName) {
+    // Strategy 0: REJECT generic/vague verbs that should be flagged
+    const genericVerbs = [
+      'do', 'handle', 'process', 'manage', 'execute',
+      'something', 'stuff', 'thing', 'work', 'data'
+    ];
+    
+    const isGenericVerb = genericVerbs.some(verb => {
+      const verbPattern = new RegExp(`^${verb}([A-Z].*|$)`, 'i');
+      return verbPattern.test(functionName);
+    });
+    
+    // Reject names starting with generic verbs
+    if (isGenericVerb) return false;
+    
     // Strategy 1: Known verb prefixes (expanded beyond static list)
     const verbPrefixes = [
       'get', 'set', 'is', 'has', 'can', 'should', 'will', 'does',
@@ -262,9 +277,9 @@ class SmartC006Analyzer {
       'delete', 'remove', 'destroy', 'clean', 'clear', 'reset',
       'load', 'save', 'fetch', 'retrieve', 'find', 'search', 'query',
       'validate', 'verify', 'check', 'confirm', 'ensure', 'test',
-      'calculate', 'compute', 'process', 'handle', 'manage', 'execute',
+      'calculate', 'compute', 'parse', 'format', 'convert',
       'send', 'receive', 'transmit', 'broadcast', 'emit', 'publish',
-      'parse', 'format', 'convert', 'map', 'filter', 'sort', 'group',
+      'map', 'filter', 'sort', 'group', 'merge', 'split',
       'connect', 'disconnect', 'open', 'close', 'start', 'stop', 'run',
       'show', 'hide', 'display', 'render', 'draw', 'paint', 'animate',
       'add', 'append', 'insert', 'push', 'pop', 'shift', 'splice',
@@ -272,7 +287,7 @@ class SmartC006Analyzer {
       'refresh', 'restore', 'reload', 'retry', 'resume', 'redirect',
       'select', 'toggle', 'switch', 'enable', 'disable', 'activate',
       'expand', 'collapse', 'scroll', 'navigate', 'submit', 'cancel',
-      'on', 'handle', 'trigger', 'fire', 'dispatch', 'invoke', 'call'
+      'on', 'trigger', 'fire', 'dispatch', 'invoke', 'call'
     ];
     
     // Strategy 2: Check if starts with known verb
@@ -365,6 +380,17 @@ class SmartC006Analyzer {
     // 🧮 CONFIDENCE CALCULATION
     let confidence = 0.5; // Base confidence
     
+    // Boost confidence for clearly generic/vague patterns
+    const vagueFunctionNames = [
+      'doSomething', 'handleStuff', 'processData', 'processInfo',
+      'executeWork', 'manageItems', 'doWork', 'handleData',
+      'something', 'stuff', 'thing', 'data', 'info', 'item'
+    ];
+    
+    if (vagueFunctionNames.some(vague => functionName.toLowerCase().includes(vague.toLowerCase()))) {
+      confidence += 0.4; // Strongly boost confidence for obviously vague names
+    }
+    
     // Boost confidence for clear noun-only patterns
     if (/^[a-z]+$/.test(functionName)) {
       confidence += 0.3; // Simple lowercase nouns: user, data