@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/base_analyzer.dart

@@ -0,0 +1,52 @@
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/source/line_info.dart';
+
+import '../models/rule.dart';
+import '../models/violation.dart';
+
+/// Base class for all rule analyzers
+abstract class BaseAnalyzer {
+  /// Rule ID this analyzer handles
+  String get ruleId;
+
+  /// Analyze a compilation unit and return violations
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  });
+
+  /// Get line number from offset
+  int getLine(LineInfo lineInfo, int offset) {
+    return lineInfo.getLocation(offset).lineNumber;
+  }
+
+  /// Get column from offset
+  int getColumn(LineInfo lineInfo, int offset) {
+    return lineInfo.getLocation(offset).columnNumber;
+  }
+
+  /// Create a violation
+  Violation createViolation({
+    required String filePath,
+    required int line,
+    required int column,
+    required String message,
+    String severity = 'warning',
+    int? confidence,
+    Map<String, dynamic>? metadata,
+  }) {
+    return Violation(
+      ruleId: ruleId,
+      filePath: filePath,
+      line: line,
+      column: column,
+      message: message,
+      severity: severity,
+      analysisMethod: 'ast',
+      confidence: confidence,
+      metadata: metadata,
+    );
+  }
+}

package/dart_analyzer/lib/rules/common/C002_no_duplicate_code.dart

@@ -0,0 +1,344 @@
+import 'dart:convert';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/source/line_info.dart';
+import 'package:crypto/crypto.dart';
+
+import '../../models/rule.dart';
+import '../../models/violation.dart';
+import '../base_analyzer.dart';
+
+/// C002: No Duplicate Code (> 10 lines)
+/// Detects duplicate code blocks that should be refactored
+/// - Finds functions/methods with similar bodies
+/// - Detects copy-pasted code blocks
+/// - Suggests extracting common logic
+class C002NoDuplicateCodeAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C002';
+
+  /// Minimum lines for duplicate detection
+  static const int minDuplicateLines = 10;
+
+  /// Similarity threshold (0.0 - 1.0)
+  static const double similarityThreshold = 0.85;
+
+  /// Store code blocks for cross-file comparison
+  final Map<String, List<_CodeBlock>> _codeBlocks = {};
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _DuplicateCodeVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+      codeBlocks: _codeBlocks,
+    );
+
+    unit.accept(visitor);
+
+    // Check for duplicates within collected blocks (only for current file)
+    _detectDuplicates(violations, filePath);
+
+    return violations;
+  }
+
+  void _detectDuplicates(List<Violation> violations, String currentFilePath) {
+    final allBlocks = _codeBlocks.values.expand((b) => b).toList();
+    final reportedPairs = <String>{};
+    
+    // Performance: Get only blocks from current file to compare against others
+    final currentFileBlocks = _codeBlocks[currentFilePath] ?? [];
+    if (currentFileBlocks.isEmpty) return;
+    
+    // Group blocks by hash for faster exact match lookups
+    final blocksByHash = <String, List<_CodeBlock>>{};
+    for (final block in allBlocks) {
+      blocksByHash.putIfAbsent(block.hash, () => []).add(block);
+    }
+
+    for (final currentBlock in currentFileBlocks) {
+      // Fast path: Check exact duplicates by hash first
+      final sameHashBlocks = blocksByHash[currentBlock.hash] ?? [];
+      for (final otherBlock in sameHashBlocks) {
+        // Skip self or same file overlapping blocks
+        if (otherBlock.filePath == currentFilePath) {
+          if (otherBlock == currentBlock || _overlaps(currentBlock, otherBlock)) {
+            continue;
+          }
+        }
+        
+        final pairKey = _createPairKey(currentBlock, otherBlock);
+        if (reportedPairs.contains(pairKey)) continue;
+        
+        reportedPairs.add(pairKey);
+        violations.add(createViolation(
+          filePath: currentBlock.filePath,
+          line: currentBlock.startLine,
+          column: 1,
+          message:
+              'Duplicate code block found (${currentBlock.lineCount} lines) - same as ${otherBlock.filePath}:${otherBlock.startLine}',
+          severity: 'warning',
+          confidence: 100,
+          metadata: {
+            'duplicateOf': '${otherBlock.filePath}:${otherBlock.startLine}',
+            'lineCount': currentBlock.lineCount,
+            'type': currentBlock.type,
+            'similarity': 1.0,
+          },
+        ));
+      }
+      
+      // Slow path: Check similar code (skip if already found exact match)
+      if (sameHashBlocks.length <= 1) {
+        for (final otherBlock in allBlocks) {
+          // Skip same file, self, or different file
+          if (otherBlock.filePath == currentFilePath) {
+            if (otherBlock == currentBlock || _overlaps(currentBlock, otherBlock)) {
+              continue;
+            }
+          }
+          
+          // Skip if not enough lines
+          if (currentBlock.lineCount < minDuplicateLines ||
+              otherBlock.lineCount < minDuplicateLines) {
+            continue;
+          }
+          
+          final pairKey = _createPairKey(currentBlock, otherBlock);
+          if (reportedPairs.contains(pairKey)) continue;
+          
+          final similarity = _calculateSimilarity(currentBlock, otherBlock);
+          if (similarity >= similarityThreshold && similarity < 1.0) {
+            reportedPairs.add(pairKey);
+            violations.add(createViolation(
+              filePath: currentBlock.filePath,
+              line: currentBlock.startLine,
+              column: 1,
+              message:
+                  'Similar code block found (${(similarity * 100).toStringAsFixed(0)}% similar) - consider extracting common logic from ${otherBlock.filePath}:${otherBlock.startLine}',
+              severity: 'warning',
+              confidence: (similarity * 100).toInt(),
+              metadata: {
+                'similarTo': '${otherBlock.filePath}:${otherBlock.startLine}',
+                'lineCount': currentBlock.lineCount,
+                'type': currentBlock.type,
+                'similarity': similarity,
+              },
+            ));
+          }
+        }
+      }
+    }
+  }
+
+  /// Create unique pair key to avoid duplicate reporting
+  String _createPairKey(_CodeBlock a, _CodeBlock b) {
+    final key1 = '${a.filePath}:${a.startLine}';
+    final key2 = '${b.filePath}:${b.startLine}';
+    // Sort keys to ensure consistent ordering
+    return key1.compareTo(key2) < 0 ? '$key1|$key2' : '$key2|$key1';
+  }
+
+  bool _overlaps(_CodeBlock a, _CodeBlock b) {
+    return !(a.endLine < b.startLine || b.endLine < a.startLine);
+  }
+
+  double _calculateSimilarity(_CodeBlock a, _CodeBlock b) {
+    final lines1 = a.normalizedLines;
+    final lines2 = b.normalizedLines;
+
+    if (lines1.isEmpty || lines2.isEmpty) return 0.0;
+
+    // Quick size difference check - if too different, skip expensive calculations
+    final maxLength = lines1.length > lines2.length ? lines1.length : lines2.length;
+    final minLength = lines1.length < lines2.length ? lines1.length : lines2.length;
+    final sizeDiff = (maxLength - minLength) / maxLength;
+    if (sizeDiff > 0.3) return 0.0; // More than 30% size difference
+
+    // Fast path: Line-by-line exact match similarity (cheapest)
+    var matchingLines = 0;
+    for (var i = 0; i < minLength; i++) {
+      if (lines1[i] == lines2[i]) {
+        matchingLines++;
+      }
+    }
+    final exactSimilarity = matchingLines / maxLength;
+    
+    // Early return if exact similarity is already high enough
+    if (exactSimilarity >= similarityThreshold) {
+      return exactSimilarity;
+    }
+
+    // Medium cost: Token-based similarity (Jaccard)
+    final tokens1 = lines1.join(' ').split(RegExp(r'\s+'));
+    final tokens2 = lines2.join(' ').split(RegExp(r'\s+'));
+    final set1 = tokens1.toSet();
+    final set2 = tokens2.toSet();
+    final intersection = set1.intersection(set2).length;
+    final union = set1.union(set2).length;
+    final jaccardSimilarity = union > 0 ? intersection / union : 0.0;
+    
+    // Early return if Jaccard is high enough
+    if (jaccardSimilarity >= similarityThreshold) {
+      return jaccardSimilarity;
+    }
+
+    // Most expensive: LCS only if needed
+    final lcsLength = _lcsLength(lines1, lines2);
+    final lcsSimilarity = lcsLength / maxLength;
+
+    // Return the maximum similarity
+    return [exactSimilarity, jaccardSimilarity, lcsSimilarity]
+        .reduce((a, b) => a > b ? a : b);
+  }
+
+  int _lcsLength(List<String> a, List<String> b) {
+    final m = a.length;
+    final n = b.length;
+    final dp = List.generate(m + 1, (_) => List.filled(n + 1, 0));
+
+    for (var i = 1; i <= m; i++) {
+      for (var j = 1; j <= n; j++) {
+        if (a[i - 1] == b[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1] + 1;
+        } else {
+          dp[i][j] = dp[i - 1][j] > dp[i][j - 1] ? dp[i - 1][j] : dp[i][j - 1];
+        }
+      }
+    }
+
+    return dp[m][n];
+  }
+
+  /// Clear collected blocks (call between analysis sessions)
+  void reset() {
+    _codeBlocks.clear();
+  }
+}
+
+class _CodeBlock {
+  final String filePath;
+  final int startLine;
+  final int endLine;
+  final String hash;
+  final List<String> normalizedLines;
+  final String type;
+
+  _CodeBlock({
+    required this.filePath,
+    required this.startLine,
+    required this.endLine,
+    required this.hash,
+    required this.normalizedLines,
+    required this.type,
+  });
+
+  int get lineCount => endLine - startLine + 1;
+}
+
+class _DuplicateCodeVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C002NoDuplicateCodeAnalyzer analyzer;
+  final Map<String, List<_CodeBlock>> codeBlocks;
+
+  _DuplicateCodeVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+    required this.codeBlocks,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    final body = node.functionExpression.body;
+    if (body is BlockFunctionBody) {
+      _processBlock(body.block, 'function', node.name.lexeme);
+    }
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    final body = node.body;
+    if (body is BlockFunctionBody) {
+      _processBlock(body.block, 'method', node.name.lexeme);
+    }
+    super.visitMethodDeclaration(node);
+  }
+
+  void _processBlock(Block block, String type, String name) {
+    final startLine = analyzer.getLine(lineInfo, block.offset);
+    final endLine = analyzer.getLine(lineInfo, block.end);
+    final lineCount = endLine - startLine + 1;
+
+    if (lineCount < C002NoDuplicateCodeAnalyzer.minDuplicateLines) return;
+
+    // Normalize code for comparison
+    final normalizedLines = _normalizeBlock(block);
+    final hash = _hashLines(normalizedLines);
+
+    final codeBlock = _CodeBlock(
+      filePath: filePath,
+      startLine: startLine,
+      endLine: endLine,
+      hash: hash,
+      normalizedLines: normalizedLines,
+      type: '$type:$name',
+    );
+
+    codeBlocks.putIfAbsent(filePath, () => []).add(codeBlock);
+  }
+
+  List<String> _normalizeBlock(Block block) {
+    final source = block.toSource();
+    return source
+        .split('\n')
+        .map((line) {
+          // Trim whitespace
+          var normalized = line.trim();
+
+          // Skip empty lines and comments
+          if (normalized.isEmpty ||
+              normalized.startsWith('//') ||
+              normalized.startsWith('/*')) {
+            return '';
+          }
+
+          // Normalize string literals (preserve quotes for structure)
+          normalized = normalized
+              .replaceAll(RegExp(r"'[^']*'"), "'_STR_'")
+              .replaceAll(RegExp(r'"[^"]*"'), '"_STR_"');
+
+          // Normalize numbers
+          normalized = normalized.replaceAll(RegExp(r'\b\d+\.?\d*\b'), '_NUM_');
+
+          // Normalize variable/parameter names (but keep method calls)
+          // Replace local variable patterns but preserve structure
+          normalized = normalized
+              .replaceAll(RegExp(r'\bfinal\s+\w+\s+='), 'final _var_ =')
+              .replaceAll(RegExp(r'\bvar\s+\w+\s+='), 'var _var_ =')
+              .replaceAll(RegExp(r'\b(\w+)\s*=\s*'), '_var_ = ');
+
+          return normalized;
+        })
+        .where((line) => line.isNotEmpty)
+        .toList();
+  }
+
+  String _hashLines(List<String> lines) {
+    final content = lines.join('\n');
+    return md5.convert(utf8.encode(content)).toString();
+  }
+}

package/dart_analyzer/lib/rules/common/C003_no_vague_abbreviations.dart

@@ -0,0 +1,318 @@
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/source/line_info.dart';
+
+import '../../models/rule.dart';
+import '../../models/violation.dart';
+import '../base_analyzer.dart';
+
+/// C003: No Vague Abbreviations
+/// Ensures clear, understandable variable names without arbitrary abbreviations
+/// - Detects unclear abbreviations (e.g., tmp, val, obj)
+/// - Allows common well-known abbreviations (id, url, api)
+/// - Enforces minimum name length
+class C003NoVagueAbbreviationsAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C003';
+
+  /// Minimum variable name length
+  static const int minNameLength = 2;
+
+  /// Allowed single character names (loop variables, etc.)
+  static final Set<String> allowedSingleChar = {
+    'i', 'j', 'k', // Loop indices
+    'x', 'y', 'z', // Coordinates
+    'e', // Exception
+    '_', // Unused
+    'a', 'b', // Generic in math
+    'n', 'm', // Count/size
+    't', // Time/temp
+  };
+
+  /// Well-known abbreviations that are allowed
+  static final Set<String> allowedAbbreviations = {
+    'id',
+    'Id',
+    'ID',
+    'url',
+    'Url',
+    'URL',
+    'api',
+    'Api',
+    'API',
+    'io',
+    'IO',
+    'db',
+    'DB',
+    'ui',
+    'UI',
+    'ok',
+    'OK',
+    'http',
+    'HTTP',
+    'json',
+    'JSON',
+    'xml',
+    'XML',
+    'html',
+    'HTML',
+    'css',
+    'CSS',
+    'sql',
+    'SQL',
+    'tcp',
+    'TCP',
+    'udp',
+    'UDP',
+    'ip',
+    'IP',
+    'os',
+    'OS',
+    'gc',
+    'GC',
+    'vm',
+    'VM',
+    'min',
+    'max',
+    'src',
+    'dst',
+    'err',
+    'msg',
+    'req',
+    'res',
+    'ctx',
+    'cfg',
+    'env',
+    'idx',
+    'len',
+    'num',
+    'str',
+    'int',
+    'ptr',
+    'ref',
+    'btn',
+    'img',
+    'doc',
+    'dir',
+    'tmp', // Allow tmp in some contexts
+  };
+
+  /// Vague abbreviations that should be avoided
+  static final Set<String> vagueAbbreviations = {
+    'val',
+    'obj',
+    'data',
+    'info',
+    'item',
+    'thing',
+    'stuff',
+    'foo',
+    'bar',
+    'baz',
+    'qux',
+    'temp',
+    'tmp2',
+    'var1',
+    'var2',
+    'str1',
+    'str2',
+    'num1',
+    'num2',
+    'test1',
+    'test2',
+    'xyz',
+    'abc',
+    'aaa',
+    'bbb',
+    'ccc',
+    'xxx',
+    'yyy',
+    'zzz',
+  };
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _AbbreviationVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+
+  /// Check if a name is a vague abbreviation
+  static bool isVagueAbbreviation(String name) {
+    final lowerName = name.toLowerCase().replaceAll('_', '');
+    return vagueAbbreviations.contains(lowerName);
+  }
+
+  /// Check if name is allowed despite being short
+  static bool isAllowedShortName(String name) {
+    // Remove leading underscores for private members
+    final cleanName = name.replaceAll(RegExp(r'^_+'), '');
+
+    if (cleanName.length == 1) {
+      return allowedSingleChar.contains(cleanName.toLowerCase());
+    }
+
+    return allowedAbbreviations.contains(cleanName) ||
+        allowedAbbreviations.contains(cleanName.toLowerCase());
+  }
+
+  /// Check if name looks like meaningless pattern (x1, y2, temp1, etc.)
+  static bool isMeaninglessPattern(String name) {
+    final cleanName = name.replaceAll(RegExp(r'^_+'), '');
+
+    // Single letter followed by numbers
+    if (RegExp(r'^[a-zA-Z]\d+$').hasMatch(cleanName)) {
+      return true;
+    }
+
+    // Common meaningless patterns
+    if (RegExp(r'^(temp|tmp|var|val|obj|data|item)\d*$', caseSensitive: false)
+        .hasMatch(cleanName)) {
+      return true;
+    }
+
+    return false;
+  }
+}
+
+class _AbbreviationVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C003NoVagueAbbreviationsAnalyzer analyzer;
+
+  _AbbreviationVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitVariableDeclaration(VariableDeclaration node) {
+    _checkName(node.name.lexeme, node.name.offset, 'Variable');
+    super.visitVariableDeclaration(node);
+  }
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    _checkName(node.name.lexeme, node.name.offset, 'Function');
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Skip operators
+    if (node.isOperator) return;
+    _checkName(node.name.lexeme, node.name.offset, 'Method');
+    super.visitMethodDeclaration(node);
+  }
+
+  @override
+  void visitSimpleFormalParameter(SimpleFormalParameter node) {
+    final name = node.name?.lexeme;
+    if (name != null) {
+      _checkName(name, node.name!.offset, 'Parameter');
+    }
+    super.visitSimpleFormalParameter(node);
+  }
+
+  @override
+  void visitFieldFormalParameter(FieldFormalParameter node) {
+    _checkName(node.name.lexeme, node.name.offset, 'Parameter');
+    super.visitFieldFormalParameter(node);
+  }
+
+  void _checkName(String name, int offset, String type) {
+    // Skip private prefix for checking
+    final cleanName = name.replaceAll(RegExp(r'^_+'), '');
+
+    // Skip if empty after cleaning
+    if (cleanName.isEmpty) return;
+
+    // Check for single character (unless allowed)
+    if (cleanName.length == 1 &&
+        !C003NoVagueAbbreviationsAnalyzer.allowedSingleChar
+            .contains(cleanName.toLowerCase())) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message:
+            '$type name "$name" is too short - use a descriptive name',
+        metadata: {
+          'name': name,
+          'type': type.toLowerCase(),
+          'issue': 'too_short',
+        },
+      ));
+      return;
+    }
+
+    // Check for vague abbreviations
+    if (C003NoVagueAbbreviationsAnalyzer.isVagueAbbreviation(cleanName)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message:
+            '$type name "$name" is too vague - use a more descriptive name',
+        metadata: {
+          'name': name,
+          'type': type.toLowerCase(),
+          'issue': 'vague_abbreviation',
+        },
+      ));
+      return;
+    }
+
+    // Check for meaningless patterns
+    if (C003NoVagueAbbreviationsAnalyzer.isMeaninglessPattern(cleanName)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message:
+            '$type name "$name" follows a meaningless pattern - use a descriptive name',
+        metadata: {
+          'name': name,
+          'type': type.toLowerCase(),
+          'issue': 'meaningless_pattern',
+        },
+      ));
+      return;
+    }
+
+    // Check minimum length for non-allowed abbreviations
+    if (cleanName.length < C003NoVagueAbbreviationsAnalyzer.minNameLength &&
+        !C003NoVagueAbbreviationsAnalyzer.isAllowedShortName(cleanName)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message:
+            '$type name "$name" is too short (min ${C003NoVagueAbbreviationsAnalyzer.minNameLength} chars) - use a descriptive name',
+        metadata: {
+          'name': name,
+          'type': type.toLowerCase(),
+          'issue': 'too_short',
+          'minLength': C003NoVagueAbbreviationsAnalyzer.minNameLength,
+        },
+      ));
+    }
+  }
+}