@sun-asterisk/sunlint 1.3.43 → 1.3.44

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

@@ -0,0 +1,112 @@
+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';
+
+/// C023: No Duplicate Variable
+/// Avoid declaring duplicate variables in the same scope
+class C023NoDuplicateVariableAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C023';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C023Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C023Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C023NoDuplicateVariableAnalyzer analyzer;
+
+  _C023Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  final List<Map<String, int>> _scopeStack = [];
+
+  void _enterScope() {
+    final newScope = <String, int>{};
+    _scopeStack.add(newScope);
+  }
+
+  void _exitScope() {
+    if (_scopeStack.isNotEmpty) {
+      _scopeStack.removeLast();
+    }
+  }
+
+  Map<String, int>? get _currentScope =>
+      _scopeStack.isEmpty ? null : _scopeStack.last;
+
+  @override
+  void visitBlock(Block node) {
+    _enterScope();
+    super.visitBlock(node);
+    _exitScope();
+  }
+
+  @override
+  void visitSwitchCase(SwitchCase node) {
+    _enterScope();
+    super.visitSwitchCase(node);
+    _exitScope();
+  }
+
+  @override
+  void visitSwitchPatternCase(SwitchPatternCase node) {
+    _enterScope();
+    super.visitSwitchPatternCase(node);
+    _exitScope();
+  }
+  
+  @override
+  void visitVariableDeclaration(VariableDeclaration node) {
+    final name = node.name.lexeme;
+    final scope = _currentScope;
+
+    // Skip if no active scope (class-level or top-level variable)
+    if (scope == null) {
+      super.visitVariableDeclaration(node);
+      return;
+    }
+    
+    if (scope.containsKey(name)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.offset),
+        column: analyzer.getColumn(lineInfo, node.offset),
+        message: 'Variable "$name" is already declared in this scope',
+      ));
+    } else {
+      scope[name] = node.offset;
+    }
+    
+    super.visitVariableDeclaration(node);
+  }
+
+}

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

@@ -0,0 +1,79 @@
+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';
+
+/// C024: No Scatter Hardcoded Constants
+/// Centralize hardcoded constants
+class C024NoScatterHardcodedConstantsAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C024';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C024Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C024Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C024NoScatterHardcodedConstantsAnalyzer analyzer;
+
+  _C024Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  final Map<String, List<int>> _stringLiterals = {};
+  
+  @override
+  void visitSimpleStringLiteral(SimpleStringLiteral node) {
+    final value = node.value;
+    
+    // Skip short strings (likely not constants)
+    if (value.length < 5) return;
+    
+    // Skip format strings and interpolations
+    if (value.contains('%') || value.contains('{')) return;
+    
+    // Track repeated literals
+    _stringLiterals.putIfAbsent(value, () => []);
+    _stringLiterals[value]!.add(node.offset);
+    
+    // Report if same literal appears multiple times
+    if (_stringLiterals[value]!.length == 2) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.offset),
+        column: analyzer.getColumn(lineInfo, node.offset),
+        message: 'Hardcoded string "$value" appears multiple times - consider extracting to a constant',
+      ));
+    }
+    
+    super.visitSimpleStringLiteral(node);
+  }
+
+}

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

@@ -0,0 +1,81 @@
+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';
+
+/// C029: Catch Block Logging
+/// Ensure proper logging in catch blocks
+class C029CatchBlockLoggingAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C029';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C029Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C029Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C029CatchBlockLoggingAnalyzer analyzer;
+
+  _C029Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitCatchClause(CatchClause node) {
+    final body = node.body;
+    final hasLogging = _containsLogging(body);
+    final hasRethrow = _containsRethrow(body);
+    
+    if (!hasLogging && !hasRethrow) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.offset),
+        column: analyzer.getColumn(lineInfo, node.offset),
+        message: 'Catch block should log the exception or rethrow it',
+      ));
+    }
+    
+    super.visitCatchClause(node);
+  }
+  
+  bool _containsLogging(Block body) {
+    final source = body.toSource();
+    return source.contains('print(') || 
+           source.contains('log(') ||
+           source.contains('logger.') ||
+           source.contains('debugPrint(');
+  }
+  
+  bool _containsRethrow(Block body) {
+    final source = body.toSource();
+    return source.contains('rethrow') || source.contains('throw ');
+  }
+
+}

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

@@ -0,0 +1,77 @@
+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';
+
+/// C030: Use Custom Error Classes
+/// Use custom error classes instead of generic errors
+class C030UseCustomErrorClassesAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C030';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C030Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C030Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C030UseCustomErrorClassesAnalyzer analyzer;
+
+  _C030Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  static const _genericExceptions = {'Exception', 'Error'};
+  
+  @override
+  void visitThrowExpression(ThrowExpression node) {
+    final expression = node.expression;
+    String? typeName;
+
+    // Handle both InstanceCreationExpression and MethodInvocation
+    if (expression is InstanceCreationExpression) {
+      typeName = expression.constructorName.type.name2.lexeme;
+    } else if (expression is MethodInvocation) {
+      // In Dart, Exception('msg') is parsed as MethodInvocation
+      typeName = expression.methodName.name;
+    }
+
+    if (typeName != null && _genericExceptions.contains(typeName)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.offset),
+        column: analyzer.getColumn(lineInfo, node.offset),
+        message: 'Use a custom exception class instead of generic "$typeName"',
+      ));
+    }
+
+    super.visitThrowExpression(node);
+  }
+
+}

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

@@ -0,0 +1,90 @@
+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';
+
+/// C031: Validation Separation
+/// Separate validation logic from business logic
+class C031ValidationSeparationAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C031';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C031Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C031Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C031ValidationSeparationAnalyzer analyzer;
+
+  _C031Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    final name = node.name.lexeme;
+    final body = node.body;
+    
+    // Skip validation methods themselves
+    if (name.contains('validate') || name.contains('Validate')) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+    
+    // Check if method contains inline validation
+    if (body != null) {
+      final source = body.toSource();
+      final validationPatterns = [
+        RegExp(r'if\s*\(.*==\s*null'),
+        RegExp(r'if\s*\(.*\.isEmpty'),
+        RegExp(r'if\s*\(.*\.length\s*[<>=]'),
+        RegExp(r'throw.*Invalid'),
+        RegExp(r'throw.*Argument'),
+      ];
+      
+      int validationCount = 0;
+      for (final pattern in validationPatterns) {
+        if (pattern.hasMatch(source)) validationCount++;
+      }
+      
+      if (validationCount >= 3) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Method "$name" contains too much inline validation - consider extracting to a validate method',
+        ));
+      }
+    }
+    
+    super.visitMethodDeclaration(node);
+  }
+
+}

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

@@ -0,0 +1,80 @@
+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';
+
+/// C033: Separate Service Repository
+/// Maintain separation between service and repository layers
+class C033SeparateServiceRepositoryAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C033';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C033Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C033Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C033SeparateServiceRepositoryAnalyzer analyzer;
+
+  _C033Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    final className = node.name.lexeme;
+    
+    // Check if it's a service class
+    if (className.endsWith('Service')) {
+      // Look for direct database/storage access
+      final source = node.toSource();
+      final dbPatterns = [
+        'Database', 'Firestore', 'SharedPreferences',
+        'Hive', 'sqflite', 'drift', '.collection(',
+        '.doc(', '.get()', '.set(', '.delete('
+      ];
+      
+      for (final pattern in dbPatterns) {
+        if (source.contains(pattern)) {
+          violations.add(analyzer.createViolation(
+            filePath: filePath,
+            line: analyzer.getLine(lineInfo, node.offset),
+            column: analyzer.getColumn(lineInfo, node.offset),
+            message: 'Service class "$className" should not directly access database - use a Repository instead',
+          ));
+          break;
+        }
+      }
+    }
+    
+    super.visitClassDeclaration(node);
+  }
+
+}

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

@@ -0,0 +1,148 @@
+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';
+
+/// C035: Error Logging Context
+/// Include context information in error logging
+class C035ErrorLoggingContextAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C035';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C035Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C035Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C035ErrorLoggingContextAnalyzer analyzer;
+
+  _C035Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitCatchClause(CatchClause node) {
+    // Visit statements in the catch block to find log calls
+    for (final statement in node.body.statements) {
+      _checkLoggingStatement(statement, node);
+    }
+
+    super.visitCatchClause(node);
+  }
+
+  void _checkLoggingStatement(Statement statement, CatchClause catchNode) {
+    if (statement is! ExpressionStatement) return;
+
+    final expr = statement.expression;
+    String? methodName;
+    ArgumentList? argList;
+
+    // Handle both MethodInvocation and FunctionExpressionInvocation
+    if (expr is MethodInvocation) {
+      methodName = expr.methodName.name.toLowerCase();
+      argList = expr.argumentList;
+    } else if (expr is FunctionExpressionInvocation) {
+      // Handle print(), log() as top-level function calls
+      final function = expr.function;
+      if (function is Identifier) {
+        methodName = function.name.toLowerCase();
+        argList = expr.argumentList;
+      }
+    }
+
+    if (methodName == null || argList == null) return;
+
+    // Check if it's a logging call
+    if (methodName == 'print' || methodName == 'log' ||
+        methodName == 'error' || methodName == 'warning' ||
+        methodName == 'info' || methodName == 'debug') {
+
+      // Check if any argument contains context (interpolation, variables)
+      bool hasContext = false;
+
+      for (final arg in argList.arguments) {
+        // Check if argument contains string interpolation (dynamic content)
+        if (arg is StringInterpolation) {
+          hasContext = true;
+          break;
+        }
+        // Check if argument is a variable/identifier (not just string literal)
+        if (arg is Identifier) {
+          hasContext = true;
+          break;
+        }
+        // Check if argument uses the exception variable via toSource
+        if (arg is SimpleStringLiteral) {
+          // Simple string literals without interpolation are considered lacking context
+          // unless they contain $ which would be strange
+          final argSource = arg.toSource();
+          if (argSource.contains(r'$')) {
+            hasContext = true;
+            break;
+          }
+        }
+      }
+
+      // Also check if the caught exception is used as a variable (not inside strings)
+      final exceptionParam = catchNode.exceptionParameter;
+      if (exceptionParam != null) {
+        final exceptionName = exceptionParam.name.lexeme;
+        // Check if exception is passed as argument (not inside string literal)
+        for (final arg in argList.arguments) {
+          if (arg is Identifier && arg.name == exceptionName) {
+            hasContext = true;
+            break;
+          }
+          // Check in string interpolation
+          if (arg is StringInterpolation) {
+            for (final element in arg.elements) {
+              if (element is InterpolationExpression) {
+                if (element.expression.toSource().contains(exceptionName)) {
+                  hasContext = true;
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+
+      if (!hasContext) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, statement.offset),
+          column: analyzer.getColumn(lineInfo, statement.offset),
+          message: 'Error logging should include context information (e.g., error details, userId, requestId)',
+        ));
+      }
+    }
+  }
+
+}