@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/dart/D013_single_public_class.dart

@@ -0,0 +1,246 @@
+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';
+
+/// D013: Prefer a Single Public Class Per File
+/// Each file should contain only one public class to improve code organization and maintainability
+/// 
+/// Exceptions:
+/// - Sealed classes / union types with small implementations (<20 lines each)
+/// - Multiple small classes (<20 lines) that share a common base class
+class D013SinglePublicClassAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D013';
+
+  // Maximum lines for a "small" class in a sealed/union pattern
+  static const int _maxLinesForSmallClass = 20;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D013Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D013Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D013SinglePublicClassAnalyzer analyzer;
+
+  final List<ClassDeclaration> _publicClasses = [];
+  final Map<String, _ClassInfo> _classInfoMap = {};
+
+  _D013Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitCompilationUnit(CompilationUnit node) {
+    // First pass: collect all public classes and their metadata
+    _publicClasses.clear();
+    _classInfoMap.clear();
+    super.visitCompilationUnit(node);
+
+    // Second pass: analyze if multiple public classes are acceptable
+    if (_publicClasses.length > 1) {
+      // Check for Flutter Widget + public State pattern
+      final widgetStateIssue = _checkFlutterWidgetStatePattern();
+      if (widgetStateIssue != null) {
+        violations.add(widgetStateIssue);
+        return;
+      }
+
+      if (!_isAcceptableMultipleClasses()) {
+        final firstClass = _publicClasses[0];
+        final classNames = _publicClasses.map((c) => c.name.lexeme).join(', ');
+
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, firstClass.name.offset),
+          column: analyzer.getColumn(lineInfo, firstClass.name.offset),
+          message:
+              'File contains ${_publicClasses.length} public classes: $classNames. Consider moving them to separate files (one public class per file).',
+        ));
+      }
+    }
+  }
+
+  /// Check for Flutter Widget with public State class pattern
+  /// Returns a violation if found, null otherwise
+  Violation? _checkFlutterWidgetStatePattern() {
+    if (_publicClasses.length != 2) return null;
+
+    ClassDeclaration? widgetClass;
+    ClassDeclaration? stateClass;
+
+    for (final cls in _publicClasses) {
+      final info = _classInfoMap[cls.name.lexeme];
+      if (info == null) continue;
+
+      if (info.baseClassName == 'StatefulWidget') {
+        widgetClass = cls;
+      } else if (info.baseClassName == 'State') {
+        stateClass = cls;
+      }
+    }
+
+    // If we have a StatefulWidget and a public State class
+    if (widgetClass != null && stateClass != null) {
+      final widgetName = widgetClass.name.lexeme;
+      final stateName = stateClass.name.lexeme;
+
+      // Check if State class name follows the pattern: WidgetNameState
+      // This confirms they're related
+      if (stateName.endsWith('State') && 
+          (stateName == '${widgetName}State' || 
+           stateName.startsWith(widgetName))) {
+        return analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, stateClass.name.offset),
+          column: analyzer.getColumn(lineInfo, stateClass.name.offset),
+          message:
+              'State class "$stateName" should be private (prefix with underscore: _$stateName). Public State classes expose internal implementation details.',
+        );
+      }
+    }
+
+    return null;
+  }
+
+  /// Check if multiple public classes are acceptable (sealed class pattern)
+  bool _isAcceptableMultipleClasses() {
+    // Find sealed classes or potential base classes
+    final sealedClasses = <String>[];
+    final baseClasses = <String>{};
+
+    for (final cls in _publicClasses) {
+      final className = cls.name.lexeme;
+      final info = _classInfoMap[className];
+      if (info == null) continue;
+
+      // Check if it's a sealed class (has 'sealed' modifier)
+      if (info.isSealed) {
+        sealedClasses.add(className);
+      }
+
+      // Check if other classes extend/implement this class
+      final childCount = _publicClasses.where((c) {
+        final childInfo = _classInfoMap[c.name.lexeme];
+        return childInfo != null && childInfo.baseClassName == className;
+      }).length;
+
+      if (childCount > 0) {
+        baseClasses.add(className);
+      }
+    }
+
+    // If we have sealed/base classes, check if all child classes are small
+    if (sealedClasses.isNotEmpty || baseClasses.isNotEmpty) {
+      final allBasesAndChildren = <String>{...sealedClasses, ...baseClasses};
+
+      // Get all classes that extend a base class
+      final childClasses = _publicClasses.where((cls) {
+        final info = _classInfoMap[cls.name.lexeme];
+        return info != null &&
+            info.baseClassName != null &&
+            allBasesAndChildren.contains(info.baseClassName);
+      }).toList();
+
+      // Check if there are any standalone classes (not base, not child)
+      final standaloneClasses = _publicClasses.where((cls) {
+        final className = cls.name.lexeme;
+        final info = _classInfoMap[className];
+        return !allBasesAndChildren.contains(className) &&
+            (info?.baseClassName == null ||
+                !allBasesAndChildren.contains(info?.baseClassName));
+      }).toList();
+
+      // Allow if:
+      // 1. All child classes are small (<20 lines)
+      // 2. There's at most one standalone class (the main class of the file)
+      final allChildrenSmall = childClasses.every((cls) {
+        final info = _classInfoMap[cls.name.lexeme];
+        return info != null &&
+            info.lineCount <=
+                D013SinglePublicClassAnalyzer._maxLinesForSmallClass;
+      });
+
+      return allChildrenSmall && standaloneClasses.length <= 1;
+    }
+
+    return false;
+  }
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    final className = node.name.lexeme;
+
+    // Check if class is public (doesn't start with underscore)
+    if (!className.startsWith('_')) {
+      _publicClasses.add(node);
+
+      // Collect metadata about the class
+      final startLine = lineInfo.getLocation(node.offset).lineNumber;
+      final endLine = lineInfo.getLocation(node.end).lineNumber;
+      final lineCount = endLine - startLine + 1;
+
+      // Check if it's a sealed class
+      final isSealed = node.sealedKeyword != null;
+
+      // Get base class name if any
+      String? baseClassName;
+      if (node.extendsClause != null) {
+        baseClassName = node.extendsClause!.superclass.name2.lexeme;
+      } else if (node.implementsClause != null &&
+          node.implementsClause!.interfaces.isNotEmpty) {
+        baseClassName = node.implementsClause!.interfaces.first.name2.lexeme;
+      }
+
+      _classInfoMap[className] = _ClassInfo(
+        className: className,
+        lineCount: lineCount,
+        isSealed: isSealed,
+        baseClassName: baseClassName,
+      );
+    }
+
+    super.visitClassDeclaration(node);
+  }
+}
+
+class _ClassInfo {
+  final String className;
+  final int lineCount;
+  final bool isSealed;
+  final String? baseClassName;
+
+  _ClassInfo({
+    required this.className,
+    required this.lineCount,
+    required this.isSealed,
+    this.baseClassName,
+  });
+}

package/dart_analyzer/lib/rules/dart/D014_unsafe_collection_access.dart

@@ -0,0 +1,202 @@
+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';
+
+/// D014: Avoid Unsafe Collection Access
+/// Always check collection empty or length before using first, last, single, or elementAt
+class D014UnsafeCollectionAccessAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D014';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D014Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D014Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D014UnsafeCollectionAccessAnalyzer analyzer;
+
+  // Unsafe collection access properties
+  static const _unsafeProperties = ['first', 'last', 'single'];
+  
+  // Unsafe collection access methods
+  static const _unsafeMethods = ['firstWhere', 'lastWhere', 'singleWhere', 'elementAt'];
+  
+  // Safe alternatives
+  static const _safeAlternatives = {
+    'first': 'firstOrNull',
+    'last': 'lastOrNull',
+    'single': 'singleOrNull',
+    'firstWhere': 'orElse parameter',
+    'lastWhere': 'orElse parameter',
+    'singleWhere': 'orElse parameter',
+    'elementAt': 'length check',
+  };
+
+  _D014Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitPropertyAccess(PropertyAccess node) {
+    final propertyName = node.propertyName.name;
+
+    // Check if it's one of the unsafe properties
+    if (_unsafeProperties.contains(propertyName)) {
+      // Skip if using null-aware operator (?.)
+      if (node.operator.type.toString() == '?.') {
+        super.visitPropertyAccess(node);
+        return;
+      }
+      
+      // Check if it's protected by a safety check
+      if (!_isProtectedByCheck(node)) {
+        final alternative = _safeAlternatives[propertyName] ?? 'safe alternative';
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.propertyName.offset),
+          column: analyzer.getColumn(lineInfo, node.propertyName.offset),
+          message:
+              'Unsafe collection access ".$propertyName" may throw if collection is empty. Consider checking isEmpty/length first or use ".$alternative" from collection package.',
+        ));
+      }
+    }
+
+    super.visitPropertyAccess(node);
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final methodName = node.methodName.name;
+
+    // Check for unsafe methods like elementAt, firstWhere, lastWhere, singleWhere
+    if (_unsafeMethods.contains(methodName)) {
+      // For firstWhere, lastWhere, singleWhere - check if orElse parameter is provided
+      if (['firstWhere', 'lastWhere', 'singleWhere'].contains(methodName)) {
+        // Check if orElse parameter is provided
+        final hasOrElse = node.argumentList.arguments.any((arg) {
+          if (arg is NamedExpression) {
+            return arg.name.label.name == 'orElse';
+          }
+          return false;
+        });
+        
+        if (hasOrElse) {
+          super.visitMethodInvocation(node);
+          return;
+        }
+      }
+      
+      if (!_isProtectedByCheck(node)) {
+        String message;
+        if (methodName == 'elementAt') {
+          message = 'Unsafe collection access ".$methodName()" may throw if index is out of bounds. Consider checking length first.';
+        } else {
+          message = 'Unsafe collection access ".$methodName()" may throw if element not found. Consider providing an "orElse" parameter.';
+        }
+        
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.methodName.offset),
+          column: analyzer.getColumn(lineInfo, node.methodName.offset),
+          message: message,
+        ));
+      }
+    }
+
+    super.visitMethodInvocation(node);
+  }
+
+  @override
+  void visitIndexExpression(IndexExpression node) {
+    // Check if target is a Map (skip Maps as per spec)
+    final targetType = node.target?.staticType?.toString() ?? '';
+    
+    // Skip if it's a Map type
+    if (targetType.contains('Map<') || targetType == 'Map') {
+      super.visitIndexExpression(node);
+      return;
+    }
+
+    // Check if it's on a collection (List, Iterable, etc.)
+    if (targetType.contains('List<') || 
+        targetType.contains('Iterable<') ||
+        targetType == 'List' ||
+        targetType == 'Iterable') {
+      if (!_isProtectedByCheck(node)) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.leftBracket.offset),
+          column: analyzer.getColumn(lineInfo, node.leftBracket.offset),
+          message:
+              'Unsafe collection access using [] operator may throw if index is out of bounds. Consider checking length first or use "elementAtOrNull" from collection package.',
+        ));
+      }
+    }
+
+    super.visitIndexExpression(node);
+  }
+
+  /// Check if the collection access is protected by a safety check
+  bool _isProtectedByCheck(AstNode node) {
+    AstNode? current = node.parent;
+
+    while (current != null) {
+      // Check if inside an if statement with safety check
+      if (current is IfStatement) {
+        final condition = current.expression;
+        if (_containsSafetyCheck(condition)) {
+          return true;
+        }
+      }
+
+      // Check if inside a conditional expression with safety check
+      if (current is ConditionalExpression) {
+        if (_containsSafetyCheck(current.condition)) {
+          return true;
+        }
+      }
+
+      current = current.parent;
+    }
+
+    return false;
+  }
+
+  /// Check if an expression contains safety checks like isEmpty, isNotEmpty, length > 0
+  bool _containsSafetyCheck(Expression expr) {
+    final exprSource = expr.toString();
+    
+    // Check for common safety patterns
+    return exprSource.contains('isEmpty') ||
+        exprSource.contains('isNotEmpty') ||
+        exprSource.contains('.length');
+  }
+}

package/dart_analyzer/lib/rules/dart/D015_copywith_all_parameters.dart

@@ -0,0 +1,125 @@
+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';
+
+/// D015: Ensure copyWith includes all constructor parameters
+/// When a class has a copyWith method, it should include all constructor parameters
+class D015CopyWithAllParametersAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D015';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D015Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D015Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D015CopyWithAllParametersAnalyzer analyzer;
+
+  // Track classes being analyzed
+  ClassDeclaration? _currentClass;
+  final Map<String, Set<String>> _classConstructorParams = {};
+  final Map<String, Set<String>> _classCopyWithParams = {};
+  final Map<String, MethodDeclaration> _classCopyWithMethods = {};
+
+  _D015Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    _currentClass = node;
+    final className = node.name.lexeme;
+    
+    // Collect constructor parameters
+    final constructorParams = <String>{};
+    for (final member in node.members) {
+      if (member is ConstructorDeclaration && member.name == null) {
+        // Default constructor
+        for (final param in member.parameters.parameters) {
+          if (param is DefaultFormalParameter) {
+            constructorParams.add(param.parameter.name?.lexeme ?? '');
+          } else if (param is SimpleFormalParameter) {
+            constructorParams.add(param.name?.lexeme ?? '');
+          } else if (param is FieldFormalParameter) {
+            constructorParams.add(param.name.lexeme);
+          }
+        }
+      }
+    }
+    
+    _classConstructorParams[className] = constructorParams;
+    
+    super.visitClassDeclaration(node);
+    
+    // After visiting all members, check if copyWith exists and compare
+    if (_classCopyWithMethods.containsKey(className)) {
+      final copyWithParams = _classCopyWithParams[className] ?? {};
+      final missingParams = constructorParams.difference(copyWithParams);
+      
+      if (missingParams.isNotEmpty) {
+        final copyWithMethod = _classCopyWithMethods[className]!;
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, copyWithMethod.name.offset),
+          column: analyzer.getColumn(lineInfo, copyWithMethod.name.offset),
+          message:
+              'copyWith method in class "$className" is missing parameters: ${missingParams.join(', ')}. All constructor parameters should be included in copyWith.',
+        ));
+      }
+    }
+    
+    _currentClass = null;
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    if (_currentClass != null && node.name.lexeme == 'copyWith') {
+      final className = _currentClass!.name.lexeme;
+      _classCopyWithMethods[className] = node;
+      
+      // Collect copyWith parameters
+      final copyWithParams = <String>{};
+      if (node.parameters != null) {
+        for (final param in node.parameters!.parameters) {
+          if (param is DefaultFormalParameter) {
+            copyWithParams.add(param.parameter.name?.lexeme ?? '');
+          } else if (param is SimpleFormalParameter) {
+            copyWithParams.add(param.name?.lexeme ?? '');
+          }
+        }
+      }
+      
+      _classCopyWithParams[className] = copyWithParams;
+    }
+    
+    super.visitMethodDeclaration(node);
+  }
+}

package/dart_analyzer/lib/rules/dart/D016_project_should_have_tests.dart

@@ -0,0 +1,134 @@
+import 'dart:io';
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/source/line_info.dart';
+import 'package:path/path.dart' as path;
+
+import '../../models/rule.dart';
+import '../../models/violation.dart';
+import '../base_analyzer.dart';
+
+/// D016: Project Should Have Tests
+/// Ensures the project has a test directory with test files
+class D016ProjectShouldHaveTestsAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D016';
+
+  // Default test directories to look for
+  static const _defaultTestDirectories = ['test', 'integration_test'];
+
+  // Test file pattern
+  static final _testFilePattern = RegExp(r'_test\.dart$');
+
+  // Track which projects we've already checked to avoid duplicate checks
+  static final Set<String> _checkedProjects = {};
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    // This rule checks for test directory existence, not individual Dart files
+    // We only need to check once per project
+    final projectRoot = _findProjectRoot(filePath);
+    if (projectRoot == null) {
+      return violations;
+    }
+
+    // Performance optimization: Skip if we've already checked this project
+    if (_checkedProjects.contains(projectRoot)) {
+      return violations;
+    }
+
+    // Mark as checked immediately
+    _checkedProjects.add(projectRoot);
+
+    // Get test directories from config, default to ['test', 'integration_test']
+    final testDirectories = (rule.config['testDirectories'] as List?)
+            ?.map((e) => e.toString())
+            .toList() ??
+        _defaultTestDirectories;
+
+    // Get minimum required test files from config, default to 1
+    final minTestFiles = (rule.config['minTestFiles'] as int?) ?? 1;
+
+    // Check if any test directory exists with test files
+    bool foundTestDirectory = false;
+    int totalTestFiles = 0;
+
+    for (final testDir in testDirectories) {
+      final testDirPath = path.join(projectRoot, testDir);
+      final testDirectory = Directory(testDirPath);
+
+      if (testDirectory.existsSync()) {
+        foundTestDirectory = true;
+        
+        // Count test files in this directory
+        final testFiles = _findTestFiles(testDirectory);
+        totalTestFiles += testFiles.length;
+      }
+    }
+
+    // Report violations
+    if (!foundTestDirectory) {
+      violations.add(createViolation(
+        filePath: filePath,
+        line: 1,
+        column: 1,
+        message:
+            'Project should have a test directory. Create a "test" directory with test files to ensure code quality and prevent regressions.',
+      ));
+    } else if (totalTestFiles < minTestFiles) {
+      violations.add(createViolation(
+        filePath: filePath,
+        line: 1,
+        column: 1,
+        message:
+            'Project has a test directory but contains only $totalTestFiles test file(s). '
+            'Add more test files (minimum: $minTestFiles) to properly test your code.',
+      ));
+    }
+
+    return violations;
+  }
+
+  /// Find the project root by looking for pubspec.yaml
+  String? _findProjectRoot(String filePath) {
+    var dir = Directory(path.dirname(filePath));
+
+    while (dir.path != dir.parent.path) {
+      final pubspec = File(path.join(dir.path, 'pubspec.yaml'));
+      if (pubspec.existsSync()) {
+        return dir.path;
+      }
+      dir = dir.parent;
+    }
+
+    return null;
+  }
+
+  /// Find all test files in a directory (recursively)
+  List<File> _findTestFiles(Directory directory) {
+    final testFiles = <File>[];
+
+    try {
+      final entities = directory.listSync(recursive: true);
+      for (final entity in entities) {
+        if (entity is File) {
+          final fileName = path.basename(entity.path);
+          if (_testFilePattern.hasMatch(fileName)) {
+            testFiles.add(entity);
+          }
+        }
+      }
+    } catch (e) {
+      // If we can't read the directory, return empty list
+    }
+
+    return testFiles;
+  }
+}