@sun-asterisk/sunlint 1.3.43 → 1.3.44

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

@@ -0,0 +1,95 @@
+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';
+
+/// C052: Parsing Or Data Transformation
+/// Separate parsing from business logic
+class C052ParsingOrDataTransformationAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C052';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C052Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C052Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C052ParsingOrDataTransformationAnalyzer analyzer;
+
+  _C052Visitor({
+    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 parse/transform methods
+    if (name.contains('parse') || name.contains('Parse') ||
+        name.contains('transform') || name.contains('Transform') ||
+        name.contains('convert') || name.contains('Convert') ||
+        name.contains('fromJson') || name.contains('toJson')) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+    
+    // Check for inline parsing in business methods
+    final source = body.toSource();
+    final parsingPatterns = [
+      'json.decode',
+      'jsonDecode',
+      'utf8.decode',
+      'int.parse',
+      'double.parse',
+      'DateTime.parse',
+      '.fromJson(',
+      '.toJson()',
+    ];
+
+    int parseCount = 0;
+    for (final pattern in parsingPatterns) {
+      if (source.contains(pattern)) parseCount++;
+    }
+
+    if (parseCount >= 2) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.offset),
+        column: analyzer.getColumn(lineInfo, node.offset),
+        message:
+            'Method "$name" contains multiple parsing operations - consider extracting to a separate method',
+      ));
+    }
+      
+    super.visitMethodDeclaration(node);
+  }
+
+}

package/dart_analyzer/lib/rules/common/C060_no_override_superclass.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';
+
+/// C060: No Override Superclass
+/// Avoid overriding superclass methods improperly
+class C060NoOverrideSuperclassAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C060';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C060Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C060Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C060NoOverrideSuperclassAnalyzer analyzer;
+
+  _C060Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Check if method has @override annotation
+    final hasOverride = node.metadata.any((m) => m.name.name == 'override');
+    
+    if (hasOverride) {
+      final body = node.body;
+      
+      // Check if override just calls super without modification
+      if (body is BlockFunctionBody) {
+        final statements = body.block.statements;
+        if (statements.length == 1) {
+          final stmt = statements.first;
+          if (stmt is ReturnStatement) {
+            final source = stmt.expression?.toSource() ?? '';
+            if (source.startsWith('super.${node.name.lexeme}(')) {
+              violations.add(analyzer.createViolation(
+                filePath: filePath,
+                line: analyzer.getLine(lineInfo, node.offset),
+                column: analyzer.getColumn(lineInfo, node.offset),
+                message: 'Override of "${node.name.lexeme}" just calls super - consider removing unnecessary override',
+              ));
+            }
+          }
+        }
+      }
+    }
+    
+    super.visitMethodDeclaration(node);
+  }
+
+}

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

@@ -0,0 +1,83 @@
+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';
+
+/// C065: One Behavior Per Test
+/// Each test should verify a single behavior
+class C065OneBehaviorPerTestAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C065';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C065Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C065Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C065OneBehaviorPerTestAnalyzer analyzer;
+
+  _C065Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final name = node.methodName.name;
+    
+    // Check test methods
+    if (name == 'test' || name == 'testWidgets') {
+      final arguments = node.argumentList.arguments;
+      if (arguments.length >= 2) {
+        final callback = arguments[1];
+        if (callback is FunctionExpression) {
+          final body = callback.body;
+          if (body is BlockFunctionBody) {
+            // Count expect/verify calls
+            final source = body.toSource();
+            final expectCount = 'expect('.allMatches(source).length;
+            final verifyCount = 'verify('.allMatches(source).length;
+            
+            if (expectCount + verifyCount > 3) {
+              violations.add(analyzer.createViolation(
+                filePath: filePath,
+                line: analyzer.getLine(lineInfo, node.offset),
+                column: analyzer.getColumn(lineInfo, node.offset),
+                message: 'Test has too many assertions (${expectCount + verifyCount}) - consider splitting into multiple tests',
+              ));
+            }
+          }
+        }
+      }
+    }
+    
+    super.visitMethodInvocation(node);
+  }
+
+}

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

@@ -0,0 +1,89 @@
+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';
+
+/// C067: No Hardcoded Config
+/// Avoid hardcoding configuration values
+class C067NoHardcodedConfigAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C067';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C067Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C067Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C067NoHardcodedConfigAnalyzer analyzer;
+
+  _C067Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  static const _configPatterns = [
+    'http://', 'https://', 'localhost',
+    ':8080', ':3000', ':5000',
+    'api/v1', 'api/v2',
+  ];
+  
+  @override
+  void visitSimpleStringLiteral(SimpleStringLiteral node) {
+    final value = node.value;
+
+    // Skip if it's in a config file (but not test fixtures)
+    // Allow config definition files but flag usage in regular code
+    if ((filePath.contains('/config/') || filePath.contains('/config.dart')) &&
+        !filePath.contains('rule-test-fixtures')) {
+      super.visitSimpleStringLiteral(node);
+      return;
+    }
+
+    // Skip test files
+    if (filePath.contains('_test.dart') && !filePath.contains('rule-test-fixtures')) {
+      super.visitSimpleStringLiteral(node);
+      return;
+    }
+
+    for (final pattern in _configPatterns) {
+      if (value.contains(pattern)) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Hardcoded configuration value detected - consider using environment variables or config files',
+        ));
+        break;
+      }
+    }
+
+    super.visitSimpleStringLiteral(node);
+  }
+
+}

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

@@ -0,0 +1,99 @@
+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';
+
+/// C070: No Real Time Tests
+/// Avoid tests that depend on real time
+class C070NoRealTimeTestsAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C070';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C070Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C070Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C070NoRealTimeTestsAnalyzer analyzer;
+
+  _C070Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  /// Check if file is a test file
+  bool _isTestFile() {
+    return filePath.contains('_test.dart') ||
+           filePath.contains('/test/') ||
+           filePath.contains('_tests.dart') ||
+           filePath.contains('rule-test-fixtures');
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final name = node.methodName.name;
+    final target = node.target?.toSource() ?? '';
+
+    // Check for real time dependencies in tests
+    if (_isTestFile()) {
+      // Check for sleep calls
+      if (name == 'sleep') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Avoid using sleep() in tests - use fake_async or mock timers instead',
+        ));
+      }
+
+      // Check for Future.delayed calls
+      if (name == 'delayed' && target == 'Future') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Avoid using Future.delayed() in tests - use fake_async or mock timers instead',
+        ));
+      }
+
+      // Check for DateTime.now() usage
+      if (name == 'now' && target == 'DateTime') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Avoid using DateTime.now() in tests - inject a Clock or use fixed timestamps',
+        ));
+      }
+    }
+
+    super.visitMethodInvocation(node);
+  }
+
+}

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

@@ -0,0 +1,78 @@
+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';
+
+/// C072: Single Test Behavior
+/// Each test should verify a single behavior
+class C072SingleTestBehaviorAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C072';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C072Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C072Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C072SingleTestBehaviorAnalyzer analyzer;
+
+  _C072Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final name = node.methodName.name;
+    
+    if (name == 'test' || name == 'testWidgets') {
+      final arguments = node.argumentList.arguments;
+      if (arguments.isNotEmpty) {
+        final testName = arguments.first;
+        if (testName is SimpleStringLiteral) {
+          final description = testName.value;
+          
+          // Check for multiple behaviors in test name
+          if (description.contains(' and ') || description.contains(' & ') ||
+              description.contains(', then ')) {
+            violations.add(analyzer.createViolation(
+              filePath: filePath,
+              line: analyzer.getLine(lineInfo, node.offset),
+              column: analyzer.getColumn(lineInfo, node.offset),
+              message: 'Test description suggests multiple behaviors - consider splitting into separate tests',
+            ));
+          }
+        }
+      }
+    }
+    
+    super.visitMethodInvocation(node);
+  }
+
+}

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

@@ -0,0 +1,82 @@
+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';
+
+/// C073: Validate Required Config On Startup
+/// Validate required configuration on application startup
+class C073ValidateRequiredConfigOnStartupAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C073';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C073Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C073Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C073ValidateRequiredConfigOnStartupAnalyzer analyzer;
+
+  _C073Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    final name = node.name.lexeme;
+    
+    // Check main function
+    if (name == 'main') {
+      final body = node.functionExpression.body;
+      final source = body.toSource();
+
+      // Check if config validation is performed
+      final hasConfigValidation = source.contains('validateConfig') ||
+          source.contains('checkConfig') ||
+          source.contains('ensureConfig') ||
+          source.contains('dotenv.load');
+
+      // Check for environment variable access without validation
+      if (source.contains('Platform.environment') || source.contains('env[')) {
+        if (!hasConfigValidation) {
+          violations.add(analyzer.createViolation(
+            filePath: filePath,
+            line: analyzer.getLine(lineInfo, node.offset),
+            column: analyzer.getColumn(lineInfo, node.offset),
+            message:
+                'main() accesses environment variables but does not validate configuration',
+          ));
+        }
+      }
+    }
+    
+    super.visitFunctionDeclaration(node);
+  }
+
+}

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

@@ -0,0 +1,85 @@
+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';
+
+/// C075: Explicit Return Types
+/// Functions should have explicit return type annotations
+class C075ExplicitReturnTypesAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C075';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C075Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C075Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C075ExplicitReturnTypesAnalyzer analyzer;
+
+  _C075Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    if (node.returnType == null) {
+      final name = node.name.lexeme;
+      // Skip main function
+      if (name != 'main') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Function "$name" should have an explicit return type',
+        ));
+      }
+    }
+    super.visitFunctionDeclaration(node);
+  }
+  
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    if (node.returnType == null && !node.isOperator && !node.isSetter) {
+      final name = node.name.lexeme;
+      // Skip lifecycle methods and operators
+      if (!name.startsWith('_') && name != 'build' && name != 'initState' &&
+          name != 'dispose' && name != 'didChangeDependencies') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Method "$name" should have an explicit return type',
+        ));
+      }
+    }
+    super.visitMethodDeclaration(node);
+  }
+
+}