@sun-asterisk/sunlint 1.3.43 → 1.3.44

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

@@ -0,0 +1,219 @@
+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';
+
+/// C006: Function Naming Convention
+/// Ensures function names follow verb-noun pattern
+/// - Functions should start with a verb
+/// - Allows common patterns: get, set, is, has, can, create, etc.
+class C006FunctionNamingAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C006';
+
+  /// Accepted verb prefixes for function names
+  static final Set<String> acceptedVerbs = {
+    // Getters/Queries
+    'get', 'fetch', 'retrieve', 'find', 'search', 'query', 'load', 'read',
+    // Setters/Modifiers
+    'set', 'update', 'modify', 'change', 'edit', 'alter', 'transform', 'write',
+    // Creation
+    'create', 'build', 'make', 'generate', 'construct', 'produce', 'new',
+    // Deletion
+    'delete', 'remove', 'destroy', 'clean', 'clear', 'reset', 'dispose',
+    // Validation
+    'validate', 'verify', 'check', 'confirm', 'ensure', 'test', 'compare',
+    // Computation
+    'calculate', 'compute', 'parse', 'format', 'convert', 'process',
+    // Communication
+    'send', 'receive', 'transmit', 'broadcast', 'emit', 'publish', 'notify',
+    // Collections
+    'map', 'filter', 'sort', 'group', 'merge', 'split', 'add', 'append',
+    'insert', 'push', 'pop', 'shift',
+    // State checks (Boolean)
+    'is', 'has', 'can', 'should', 'will', 'does', 'contains', 'includes', 'exists',
+    // UI actions
+    'show', 'hide', 'display', 'render', 'draw', 'toggle', 'enable', 'disable',
+    'activate', 'deactivate', 'select', 'deselect', 'focus', 'blur',
+    // Lifecycle
+    'connect', 'disconnect', 'open', 'close', 'start', 'stop', 'run', 'refresh',
+    'init', 'initialize', 'setup', 'teardown', 'shutdown', 'restart', 'reload',
+    'restore', 'resume', 'pause', 'suspend',
+    // Event Handling
+    'on', 'trigger', 'fire', 'dispatch', 'invoke', 'call', 'handle',
+    // Monitoring
+    'count', 'measure', 'monitor', 'watch', 'track', 'observe', 'log', 'record',
+    // Navigation
+    'navigate', 'redirect', 'route', 'go', 'move', 'scroll',
+    // Data Operations
+    'save', 'store', 'persist', 'cache', 'serialize', 'deserialize',
+    // Transformation
+    'normalize', 'sanitize', 'encode', 'decode', 'encrypt', 'decrypt',
+    'compress', 'decompress', 'stringify',
+    // State Management
+    'apply', 'revert', 'undo', 'redo', 'commit', 'rollback',
+    // Async Operations
+    'await', 'defer', 'debounce', 'throttle', 'delay',
+    // Error Handling
+    'recover', 'retry',
+    // Copying
+    'copy', 'clone', 'duplicate', 'replicate',
+    // Comparison
+    'equals', 'match', 'diff',
+    // Printing/Output
+    'print', 'debug', 'trace', 'dump',
+    // Try operations
+    'try',
+    // other common verbs
+    'launch', 'install', 'uninstall', 'upload', 'download', 'backup',
+    'sync', 'synchronize', 'optimize', 'cleanse', 'finalize', 'do',
+    'tracking', 'submit', 'approve', 'reject', 'archive', 'unarchive',
+    'input', 'enter', 'exit', 'wrap', 'unwrap', 'increment', 'decrement',
+    'post', 'patch', 'put', 'drop', 'bind', 'unbind', 'flatten', 'expand',
+    'elevate', 'demote', 'promote', 'subscribe', 'unsubscribe', 'share',
+    'like', 'comment', 'follow', 'unfollow', 'rate', 'review', 'report',
+    'block', 'unblock', 'mute', 'unmute', 'pin', 'unpin', 'highlight',
+    'unhighlight', 'skip', 'mark', 'tag', 'untag', 'flag', 'unflag', 'login',
+    'logout', 'did', 'complete', 'view', 'listen', 'return', 'switch', 'next',
+    'previous', 'recommend', 'suggest', 'explore', 'discover', 'arrange',
+    'link', 'unlink', 'calibrate', 'diagnose', 'repair', 'maintain', 'upgrade',
+    'downgrade', 'authen', 'author', 'play', 'stream', 'cast', 'mirror',
+    'reflect', 'seek', 'fit', 'crop', 'resize', 'rotate', 'enhance', 'adjust',
+    'blend', 'separate', 'isolate', 'synthesize', 'analyze', 'visualize',
+    'simulate', 'model', 'fill', 'stroke', 'outline', 'shade', 'animate',
+    'gen', 'calc', 'click', 'tap', 'swipe', 'pinch', 'zoom', 'drag', 'press',
+  };
+
+  /// Special functions that are allowed without verb prefix
+  static final Set<String> specialFunctions = {
+    // Dart lifecycle
+    'main', 'build', 'dispose', 'initState', 'didChangeDependencies',
+    'didUpdateWidget', 'deactivate', 'reassemble',
+    // Object methods
+    'toString', 'toJson', 'fromJson', 'toMap', 'fromMap',
+    'hashCode', 'compareTo', 'noSuchMethod',
+    // Factory constructors often use 'of' or 'from'
+    'of', 'from', 'parse', 'tryParse',
+    // Common widget methods
+    'createState',
+    // Operators
+    'operator',
+  };
+
+  /// Patterns that indicate the function is a callback/handler
+  static final RegExp callbackPattern = RegExp(
+    r'^(on[A-Z]|_on[A-Z]|handle[A-Z]|_handle[A-Z])',
+  );
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _FunctionNamingVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+
+  /// Check if a function name starts with an accepted verb
+  static bool startsWithVerb(String name) {
+    // Remove leading underscore for private functions
+    final cleanName = name.replaceAll(RegExp(r'^_+'), '');
+    if (cleanName.isEmpty) return true;
+
+    // Check if it's a special function
+    if (specialFunctions.contains(cleanName)) return true;
+
+    // Check callback pattern
+    if (callbackPattern.hasMatch(name)) return true;
+
+    // Check if starts with any accepted verb
+    final lowerName = cleanName.toLowerCase();
+    for (final verb in acceptedVerbs) {
+      if (lowerName.startsWith(verb)) {
+        // Must be followed by uppercase or end of string (verb-noun pattern)
+        if (lowerName == verb) return true;
+        final afterVerb = cleanName.substring(verb.length);
+        if (afterVerb.isNotEmpty && afterVerb[0] == afterVerb[0].toUpperCase()) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+}
+
+class _FunctionNamingVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C006FunctionNamingAnalyzer analyzer;
+
+  _FunctionNamingVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    _checkFunctionName(node.name.lexeme, node.name.offset, 'Function');
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Skip operators and property accessors
+    if (node.isOperator) return;
+    if (node.isGetter || node.isSetter) return;
+
+    _checkFunctionName(node.name.lexeme, node.name.offset, 'Method');
+    super.visitMethodDeclaration(node);
+  }
+
+  void _checkFunctionName(String name, int offset, String type) {
+    // Skip private functions starting with underscore followed by lowercase
+    // (often internal helpers)
+    if (name.startsWith('_') && name.length > 1) {
+      final afterUnderscore = name.substring(1);
+      if (afterUnderscore.isNotEmpty &&
+          afterUnderscore[0] == afterUnderscore[0].toLowerCase()) {
+        // Still check if it follows verb pattern
+        if (C006FunctionNamingAnalyzer.startsWithVerb(afterUnderscore)) {
+          return;
+        }
+      }
+    }
+
+    if (!C006FunctionNamingAnalyzer.startsWithVerb(name)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message:
+            '$type name "$name" should start with a verb (e.g., getSuccessList, createUser...)',
+        metadata: {
+          'name': name,
+          'type': type.toLowerCase(),
+          'suggestion': '',
+        },
+      ));
+    }
+  }
+}

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

@@ -0,0 +1,205 @@
+import 'dart:io';
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/source/line_info.dart';
+import 'package:sunlint_dart_analyzer/utils/common_utils.dart';
+
+import '../../models/rule.dart';
+import '../../models/violation.dart';
+import '../base_analyzer.dart';
+
+/// C008: Variable Declaration Locality
+/// Variables should be declared close to where they are first used
+class C008VariableDeclarationLocalityAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C008';
+
+  /// Maximum allowed distance between declaration and first usage
+  static const int maxLineDistance = 10;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+    final sourceContent = _readSourceContent(filePath);
+
+    final visitor = _VariableLocalityVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+      sourceContent: sourceContent,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+
+  String _readSourceContent(String filePath) {
+    try {
+      return File(filePath).readAsStringSync();
+    } catch (e) {
+      return '';
+    }
+  }
+}
+
+class _VariableLocalityVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C008VariableDeclarationLocalityAnalyzer analyzer;
+  final String sourceContent;
+  late final List<String> _sourceLines;
+
+  _VariableLocalityVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+    required this.sourceContent,
+  }) {
+    _sourceLines = sourceContent.split('\n');
+  }
+
+  @override
+  void visitBlockFunctionBody(BlockFunctionBody node) {
+    _analyzeBlock(node.block);
+    super.visitBlockFunctionBody(node);
+  }
+
+  void _analyzeBlock(Block block) {
+    final declarations = _collectVariableDeclarations(block);
+    final firstUsages = _findFirstUsages(block, declarations.keys.toSet());
+    _reportViolationsForDistantDeclarations(declarations, firstUsages);
+  }
+
+  Map<String, int> _collectVariableDeclarations(Block block) {
+    final declarations = <String, int>{};
+
+    for (final statement in block.statements) {
+      if (statement is VariableDeclarationStatement) {
+        for (final variable in statement.variables.variables) {
+          final name = variable.name.lexeme;
+          final line = analyzer.getLine(lineInfo, variable.offset);
+          declarations[name] = line;
+        }
+      }
+    }
+
+    return declarations;
+  }
+
+  Map<String, int> _findFirstUsages(Block block, Set<String> variableNames) {
+    final usageFinder = _FirstUsageFinder(
+      variableNames: variableNames,
+      lineInfo: lineInfo,
+      analyzer: analyzer,
+    );
+    block.accept(usageFinder);
+    return usageFinder.firstUsages;
+  }
+
+  void _reportViolationsForDistantDeclarations(
+    Map<String, int> declarations,
+    Map<String, int> firstUsages,
+  ) {
+    for (final entry in declarations.entries) {
+      final name = entry.key;
+      final declLine = entry.value;
+      final firstUsageLine = firstUsages[name];
+
+      if (firstUsageLine == null) continue;
+
+      final distance = _calculateDistance(declLine, firstUsageLine);
+      if (_isDistanceTooFar(distance)) {
+        _addViolation(name, declLine, firstUsageLine, distance);
+      }
+    }
+  }
+
+  int _calculateDistance(int declarationLine, int firstUsageLine) {
+    return _countNonBlankNonCommentLines(declarationLine, firstUsageLine);
+  }
+
+  int _countNonBlankNonCommentLines(int startLine, int endLine) {
+    int count = 0;
+    for (int i = startLine; i < endLine; i++) {
+      if (CommonUtils.isCodeLine(i, _sourceLines)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  bool _isDistanceTooFar(int distance) {
+    return distance > C008VariableDeclarationLocalityAnalyzer.maxLineDistance;
+  }
+
+  void _addViolation(
+    String variableName,
+    int declarationLine,
+    int firstUsageLine,
+    int distance,
+  ) {
+    violations.add(analyzer.createViolation(
+      filePath: filePath,
+      line: declarationLine,
+      column: 1,
+      message:
+          'Variable "$variableName" is declared $distance lines before first use (max: ${C008VariableDeclarationLocalityAnalyzer.maxLineDistance})',
+      metadata: {
+        'variable': variableName,
+        'declarationLine': declarationLine,
+        'firstUsageLine': firstUsageLine,
+        'distance': distance,
+      },
+    ));
+  }
+}
+
+class _FirstUsageFinder extends RecursiveAstVisitor<void> {
+  final Set<String> variableNames;
+  final LineInfo lineInfo;
+  final C008VariableDeclarationLocalityAnalyzer analyzer;
+  final Map<String, int> firstUsages = {};
+  bool _isInsideVariableDeclaration = false;
+
+  _FirstUsageFinder({
+    required this.variableNames,
+    required this.lineInfo,
+    required this.analyzer,
+  });
+
+  @override
+  void visitVariableDeclaration(VariableDeclaration node) {
+    _isInsideVariableDeclaration = true;
+    super.visitVariableDeclaration(node);
+    _isInsideVariableDeclaration = false;
+  }
+
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    if (_shouldRecordUsage(node)) {
+      _recordFirstUsageIfNotExists(node);
+    }
+    super.visitSimpleIdentifier(node);
+  }
+
+  bool _shouldRecordUsage(SimpleIdentifier node) {
+    return !_isInsideVariableDeclaration && variableNames.contains(node.name);
+  }
+
+  void _recordFirstUsageIfNotExists(SimpleIdentifier node) {
+    if (firstUsages.containsKey(node.name)) return;
+
+    final line = analyzer.getLine(lineInfo, node.offset);
+    firstUsages[node.name] = line;
+  }
+}

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

@@ -0,0 +1,162 @@
+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';
+
+/// C010: Limit Block Nesting
+/// Limit nested blocks (if/for/while/switch/try) to maximum 3 levels
+class C010LimitBlockNestingAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C010';
+
+  /// Maximum allowed nesting depth
+  static const int maxNestingDepth = 3;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _NestingVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _NestingVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C010LimitBlockNestingAnalyzer analyzer;
+  int currentDepth = 0;
+  bool _hasReportedInCurrentBlockChain = false;
+
+  _NestingVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  void _enterBlock(AstNode node) {
+    currentDepth++;
+    if (_shouldReportViolation()) {
+      _reportViolation(node);
+    }
+  }
+
+  bool _shouldReportViolation() {
+    return currentDepth > C010LimitBlockNestingAnalyzer.maxNestingDepth &&
+        !_hasReportedInCurrentBlockChain;
+  }
+
+  void _reportViolation(AstNode node) {
+    _hasReportedInCurrentBlockChain = true;
+    violations.add(analyzer.createViolation(
+      filePath: filePath,
+      line: analyzer.getLine(lineInfo, node.offset),
+      column: analyzer.getColumn(lineInfo, node.offset),
+      message:
+          'Nesting depth $currentDepth exceeds maximum of ${C010LimitBlockNestingAnalyzer.maxNestingDepth}',
+      metadata: {
+        'depth': currentDepth,
+        'maxDepth': C010LimitBlockNestingAnalyzer.maxNestingDepth,
+      },
+    ));
+  }
+
+  void _exitBlock() {
+    currentDepth--;
+    // Reset flag when we exit back to below max nesting level
+    if (currentDepth < C010LimitBlockNestingAnalyzer.maxNestingDepth) {
+      _hasReportedInCurrentBlockChain = false;
+    }
+  }
+
+  @override
+  void visitIfStatement(IfStatement node) {
+    _enterBlock(node);
+    super.visitIfStatement(node);
+    _exitBlock();
+  }
+
+  @override
+  void visitForStatement(ForStatement node) {
+    _enterBlock(node);
+    super.visitForStatement(node);
+    _exitBlock();
+  }
+
+  @override
+  void visitForElement(ForElement node) {
+    _enterBlock(node);
+    super.visitForElement(node);
+    _exitBlock();
+  }
+
+  @override
+  void visitWhileStatement(WhileStatement node) {
+    _enterBlock(node);
+    super.visitWhileStatement(node);
+    _exitBlock();
+  }
+
+  @override
+  void visitDoStatement(DoStatement node) {
+    _enterBlock(node);
+    super.visitDoStatement(node);
+    _exitBlock();
+  }
+
+  @override
+  void visitSwitchStatement(SwitchStatement node) {
+    _enterBlock(node);
+    super.visitSwitchStatement(node);
+    _exitBlock();
+  }
+
+  @override
+  void visitTryStatement(TryStatement node) {
+    _enterBlock(node);
+    super.visitTryStatement(node);
+    _exitBlock();
+  }
+
+
+  // Reset depth and flag when entering a new function/method
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    final savedDepth = currentDepth;
+    final savedFlag = _hasReportedInCurrentBlockChain;
+    currentDepth = 0;
+    _hasReportedInCurrentBlockChain = false;
+    super.visitFunctionDeclaration(node);
+    currentDepth = savedDepth;
+    _hasReportedInCurrentBlockChain = savedFlag;
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    final savedDepth = currentDepth;
+    final savedFlag = _hasReportedInCurrentBlockChain;
+    currentDepth = 0;
+    _hasReportedInCurrentBlockChain = false;
+    super.visitMethodDeclaration(node);
+    currentDepth = savedDepth;
+    _hasReportedInCurrentBlockChain = savedFlag;
+  }
+}