@sun-asterisk/sunlint 1.3.43 → 1.3.44

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

@@ -0,0 +1,158 @@
+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';
+
+/// C017: Constructor Logic
+/// Do not put business logic inside constructors
+class C017ConstructorLogicAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C017';
+
+  /// Maximum allowed statements in constructor
+  static const int maxConstructorStatements = 5;
+
+  /// Patterns that indicate business logic
+  static final Set<String> businessLogicPatterns = {
+    'fetch',
+    'load',
+    'save',
+    'delete',
+    'update',
+    'create',
+    'process',
+    'calculate',
+    'validate',
+    'send',
+    'notify',
+    'http',
+    'api',
+  };
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _ConstructorLogicVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _ConstructorLogicVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C017ConstructorLogicAnalyzer analyzer;
+
+  _ConstructorLogicVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitConstructorDeclaration(ConstructorDeclaration node) {
+    if (node.body is BlockFunctionBody) {
+      final body = node.body as BlockFunctionBody;
+      final statements = body.block.statements;
+
+      // Check for too many statements
+      if (statements.length > C017ConstructorLogicAnalyzer.maxConstructorStatements) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message:
+              'Constructor has ${statements.length} statements (max: ${C017ConstructorLogicAnalyzer.maxConstructorStatements}) - consider using init method',
+          metadata: {
+            'statementCount': statements.length,
+            'maxStatements': C017ConstructorLogicAnalyzer.maxConstructorStatements,
+            'issue': 'too_many_statements',
+          },
+        ));
+      }
+
+      // Check for business logic calls
+      final logicFinder = _BusinessLogicFinder(
+        filePath: filePath,
+        lineInfo: lineInfo,
+        violations: violations,
+        analyzer: analyzer,
+      );
+      body.block.accept(logicFinder);
+    }
+
+    super.visitConstructorDeclaration(node);
+  }
+}
+
+class _BusinessLogicFinder extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C017ConstructorLogicAnalyzer analyzer;
+
+  _BusinessLogicFinder({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final methodName = node.methodName.name.toLowerCase();
+
+    for (final pattern in C017ConstructorLogicAnalyzer.businessLogicPatterns) {
+      if (methodName.contains(pattern)) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message:
+              'Business logic method "${node.methodName.name}" should not be called in constructor',
+          metadata: {
+            'method': node.methodName.name,
+            'pattern': pattern,
+            'issue': 'business_logic_in_constructor',
+          },
+        ));
+        break;
+      }
+    }
+
+    super.visitMethodInvocation(node);
+  }
+
+  @override
+  void visitAwaitExpression(AwaitExpression node) {
+    violations.add(analyzer.createViolation(
+      filePath: filePath,
+      line: analyzer.getLine(lineInfo, node.offset),
+      column: analyzer.getColumn(lineInfo, node.offset),
+      message: 'Await in constructor indicates async business logic - consider using factory or init method',
+      metadata: {
+        'issue': 'await_in_constructor',
+      },
+    ));
+
+    super.visitAwaitExpression(node);
+  }
+}

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

@@ -0,0 +1,141 @@
+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';
+
+/// C018: No Throw Generic Error
+/// Always provide detailed messages and context for errors
+class C018NoThrowGenericErrorAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C018';
+
+  /// Generic exception types that should be avoided
+  static final Set<String> genericExceptions = {
+    'Exception',
+    'Error',
+    'StateError',
+    'ArgumentError',
+  };
+
+  /// Minimum message length for meaningful error messages
+  static const int minMessageLength = 10;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _GenericErrorVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _GenericErrorVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C018NoThrowGenericErrorAnalyzer analyzer;
+
+  _GenericErrorVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitThrowExpression(ThrowExpression node) {
+    final expression = node.expression;
+
+    String? typeName;
+    NodeList<Expression>? args;
+
+    // Handle both InstanceCreationExpression and MethodInvocation
+    // In Dart, `throw Exception('msg')` can be parsed as MethodInvocation
+    // when not using 'new' keyword
+    if (expression is InstanceCreationExpression) {
+      typeName = expression.constructorName.type.name2.lexeme;
+      args = expression.argumentList.arguments;
+    } else if (expression is MethodInvocation) {
+      // For calls like Exception('message') or Error()
+      typeName = expression.methodName.name;
+      args = expression.argumentList.arguments;
+    }
+
+    if (typeName == null || args == null) {
+      super.visitThrowExpression(node);
+      return;
+    }
+
+    // Check if it's a generic exception
+    if (C018NoThrowGenericErrorAnalyzer.genericExceptions.contains(typeName)) {
+      // Check if message is provided and meaningful
+      if (args.isEmpty) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'throw $typeName() without message - provide a descriptive error message',
+          metadata: {
+            'exceptionType': typeName,
+            'issue': 'no_message',
+          },
+        ));
+      } else {
+        final firstArg = args.first;
+        if (firstArg is StringLiteral) {
+          final message = firstArg.stringValue ?? '';
+          if (message.length < C018NoThrowGenericErrorAnalyzer.minMessageLength) {
+            violations.add(analyzer.createViolation(
+              filePath: filePath,
+              line: analyzer.getLine(lineInfo, node.offset),
+              column: analyzer.getColumn(lineInfo, node.offset),
+              message:
+                  'throw $typeName with short message "$message" - provide more context',
+              metadata: {
+                'exceptionType': typeName,
+                'message': message,
+                'issue': 'short_message',
+              },
+            ));
+          }
+        }
+      }
+
+      // Suggest using custom exception
+      if (typeName == 'Exception' || typeName == 'Error') {
+        final isException = typeName == 'Exception';
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message:
+              'Avoid throwing generic ${isException ? 'Exception' : 'Error'} - use a specific ${isException ? 'Exception' : 'Error'} type',
+          metadata: {
+            'exceptionType': typeName,
+            'issue': 'generic_exception',
+            'suggestion':
+                'Create a custom ${isException ? 'Exception' : 'Error'} class',
+          },
+        ));
+      }
+    }
+
+    super.visitThrowExpression(node);
+  }
+}

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

@@ -0,0 +1,165 @@
+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';
+
+/// C019: Log Level Usage
+/// Do not use error log level for non-critical errors
+class C019LogLevelUsageAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C019';
+
+  /// Keywords that indicate non-critical issues
+  static final Set<String> nonCriticalKeywords = {
+    'not found',
+    'invalid',
+    'unauthorized',
+    'forbidden',
+    'validation failed',
+    'bad request',
+    'cache miss',
+    'retry',
+    'fallback',
+    'user error',
+    'input error',
+    'validation',
+    'missing parameter',
+    'exceed',
+    'limit',
+  };
+
+  /// Keywords that indicate legitimate errors
+  static final Set<String> legitimateErrorKeywords = {
+    'exception',
+    'crash',
+    'fatal',
+    'critical',
+    'emergency',
+    'database',
+    'connection',
+    'timeout',
+    'security breach',
+    'system error',
+    'memory',
+    'disk space',
+    'internal server error',
+    'unhandled exception',
+    'stack overflow',
+  };
+
+  /// Error logger patterns
+  static final RegExp errorLogPattern = RegExp(
+    r'\.(error|e)\s*\(',
+    caseSensitive: false,
+  );
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _LogLevelVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _LogLevelVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C019LogLevelUsageAnalyzer analyzer;
+
+  _LogLevelVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final methodName = node.methodName.name.toLowerCase();
+
+    // Check if it's an error log call
+    if (methodName == 'error' || methodName == 'e') {
+      final args = node.argumentList.arguments;
+
+      if (args.isNotEmpty) {
+        final firstArg = args.first;
+        String? messageContent;
+
+        if (firstArg is SimpleStringLiteral) {
+          // Simple string like 'hello world'
+          messageContent = firstArg.value.toLowerCase();
+        } else if (firstArg is StringInterpolation) {
+          // Interpolated string like 'hello $name'
+          // Extract text elements only
+          final buffer = StringBuffer();
+          for (final element in firstArg.elements) {
+            if (element is InterpolationString) {
+              buffer.write(element.value);
+            }
+          }
+          messageContent = buffer.toString().toLowerCase();
+        } else if (firstArg is AdjacentStrings) {
+          // Adjacent strings like 'hello' 'world'
+          final buffer = StringBuffer();
+          for (final str in firstArg.strings) {
+            if (str is SimpleStringLiteral) {
+              buffer.write(str.value);
+            }
+          }
+          messageContent = buffer.toString().toLowerCase();
+        }
+
+        if (messageContent != null) {
+          // Check for non-critical keywords
+          for (final keyword in C019LogLevelUsageAnalyzer.nonCriticalKeywords) {
+            if (messageContent.contains(keyword)) {
+              // But skip if it also contains legitimate error keywords
+              bool hasLegitimateError = false;
+              for (final legit in C019LogLevelUsageAnalyzer.legitimateErrorKeywords) {
+                if (messageContent.contains(legit)) {
+                  hasLegitimateError = true;
+                  break;
+                }
+              }
+
+              if (!hasLegitimateError) {
+                violations.add(analyzer.createViolation(
+                  filePath: filePath,
+                  line: analyzer.getLine(lineInfo, node.offset),
+                  column: analyzer.getColumn(lineInfo, node.offset),
+                  message:
+                      'log.error() used for non-critical issue "$keyword" - consider using log.warn()',
+                  metadata: {
+                    'keyword': keyword,
+                    'suggestion': 'Use log.warn() or log.info() instead',
+                  },
+                ));
+                break;
+              }
+            }
+          }
+        }
+      }
+    }
+
+    super.visitMethodInvocation(node);
+  }
+}

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

@@ -0,0 +1,128 @@
+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';
+
+/// C020: Unused Imports
+/// Do not import unused modules or symbols
+class C020UnusedImportsAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C020';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    // Collect all imports
+    final imports = <ImportDirective>[];
+    final importedPrefixes = <String, ImportDirective>{};
+    final showClauses = <String, ImportDirective>{};
+
+    for (final directive in unit.directives) {
+      if (directive is ImportDirective) {
+        imports.add(directive);
+
+        // Track prefixed imports
+        final prefix = directive.prefix?.name;
+        if (prefix != null) {
+          importedPrefixes[prefix] = directive;
+        }
+
+        // Track show clauses
+        for (final combinator in directive.combinators) {
+          if (combinator is ShowCombinator) {
+            for (final name in combinator.shownNames) {
+              showClauses[name.name] = directive;
+            }
+          }
+        }
+      }
+    }
+
+    // Collect all identifiers used in the file
+    final usedIdentifiers = <String>{};
+    final usedPrefixes = <String>{};
+
+    final visitor = _IdentifierCollector(
+      usedIdentifiers: usedIdentifiers,
+      usedPrefixes: usedPrefixes,
+    );
+    unit.accept(visitor);
+
+    // Check for unused prefixed imports
+    for (final entry in importedPrefixes.entries) {
+      if (!usedPrefixes.contains(entry.key)) {
+        violations.add(createViolation(
+          filePath: filePath,
+          line: getLine(lineInfo, entry.value.offset),
+          column: getColumn(lineInfo, entry.value.offset),
+          message: 'Import with prefix "${entry.key}" is never used',
+          metadata: {
+            'prefix': entry.key,
+            'import': entry.value.uri.stringValue ?? '',
+            'issue': 'unused_prefix',
+          },
+        ));
+      }
+    }
+
+    // Check for unused show clause symbols
+    for (final entry in showClauses.entries) {
+      if (!usedIdentifiers.contains(entry.key)) {
+        violations.add(createViolation(
+          filePath: filePath,
+          line: getLine(lineInfo, entry.value.offset),
+          column: getColumn(lineInfo, entry.value.offset),
+          message: 'Symbol "${entry.key}" from import is never used',
+          metadata: {
+            'symbol': entry.key,
+            'import': entry.value.uri.stringValue ?? '',
+            'issue': 'unused_symbol',
+          },
+        ));
+      }
+    }
+
+    return violations;
+  }
+}
+
+class _IdentifierCollector extends RecursiveAstVisitor<void> {
+  final Set<String> usedIdentifiers;
+  final Set<String> usedPrefixes;
+
+  _IdentifierCollector({
+    required this.usedIdentifiers,
+    required this.usedPrefixes,
+  });
+
+  @override
+  void visitSimpleIdentifier(SimpleIdentifier node) {
+    usedIdentifiers.add(node.name);
+    super.visitSimpleIdentifier(node);
+  }
+
+  @override
+  void visitPrefixedIdentifier(PrefixedIdentifier node) {
+    usedPrefixes.add(node.prefix.name);
+    usedIdentifiers.add(node.identifier.name);
+    super.visitPrefixedIdentifier(node);
+  }
+
+  @override
+  void visitNamedType(NamedType node) {
+    if (node.importPrefix != null) {
+      usedPrefixes.add(node.importPrefix!.name.lexeme);
+    }
+    usedIdentifiers.add(node.name2.lexeme);
+    super.visitNamedType(node);
+  }
+}

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

@@ -0,0 +1,86 @@
+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';
+
+/// C021: Import Organization
+/// Enforce organized imports with grouping and sorting
+class C021ImportOrganizationAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C021';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C021Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C021Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C021ImportOrganizationAnalyzer analyzer;
+
+  String _lastImportType = '';
+
+  _C021Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitImportDirective(ImportDirective node) {
+    // Check import organization
+    final uri = node.uri.stringValue ?? '';
+    
+    // Track import order for validation
+    // Dart imports should follow: dart:, package:, relative
+    if (uri.startsWith('dart:')) {
+      if (_lastImportType == 'package' || _lastImportType == 'relative') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'dart: imports should come before package: and relative imports',
+        ));
+      }
+      _lastImportType = 'dart';
+    } else if (uri.startsWith('package:')) {
+      if (_lastImportType == 'relative') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'package: imports should come before relative imports',
+        ));
+      }
+      _lastImportType = 'package';
+    } else {
+      _lastImportType = 'relative';
+    }
+    
+    super.visitImportDirective(node);
+  }
+
+}