@sun-asterisk/sunlint 1.3.43 → 1.3.44

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

@@ -0,0 +1,214 @@
+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';
+
+/// C012: Command Query Separation
+/// Separate commands (modify state) from queries (return data)
+/// - Commands should return void
+/// - Queries should be pure (no side effects)
+class C012CommandQuerySeparationAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C012';
+
+  /// Patterns that indicate state modification (command)
+  static final Set<String> commandIndicators = {
+    'set', 'update', 'delete', 'remove', 'add', 'insert',
+    'save', 'store', 'persist', 'write', 'modify', 'mutate',
+    'push', 'pop', 'shift', 'create', 'destroy', 'clear',
+  };
+
+  /// Patterns that indicate data retrieval (query)
+  static final Set<String> queryIndicators = {
+    'get', 'find', 'fetch', 'retrieve', 'load', 'read',
+    'calculate', 'compute', 'is', 'has', 'can', 'should',
+  };
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _CQSVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _CQSVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C012CommandQuerySeparationAnalyzer analyzer;
+
+  _CQSVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Skip getters, setters, and operators
+    if (node.isGetter || node.isSetter || node.isOperator) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    _checkCQS(node.name.lexeme, node.returnType, node.body, node.offset);
+    super.visitMethodDeclaration(node);
+  }
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    _checkCQS(
+      node.name.lexeme,
+      node.returnType,
+      node.functionExpression.body,
+      node.offset,
+    );
+    super.visitFunctionDeclaration(node);
+  }
+
+  void _checkCQS(
+    String name,
+    TypeAnnotation? returnType,
+    FunctionBody? body,
+    int offset,
+  ) {
+    final lowerName = name.toLowerCase();
+    final returnTypeStr = returnType?.toSource() ?? '';
+
+    // Check if it's a command (modifies state)
+    final isCommand = _isCommand(lowerName, body);
+
+    // Check if it returns a value (not void/Future<void>)
+    final returnsValue = _returnsValue(returnTypeStr, body);
+
+    // CQS violation: command that returns value
+    if (isCommand && returnsValue) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message:
+            'Method "$name" violates CQS: modifies state AND returns value. Separate into command and query.',
+        metadata: {
+          'method': name,
+          'returnType': returnTypeStr,
+          'issue': 'cqs_violation',
+          'suggestion': 'Split into void command method and separate query method',
+        },
+      ));
+    }
+  }
+
+  bool _isCommand(String name, FunctionBody? body) {
+    // Check name for command indicators
+    for (final indicator in C012CommandQuerySeparationAnalyzer.commandIndicators) {
+      if (name.startsWith(indicator) || name.contains(indicator.capitalize())) {
+        return true;
+      }
+    }
+
+    // Check body for state modifications
+    if (body is BlockFunctionBody) {
+      final finder = _StateMutationFinder();
+      body.block.accept(finder);
+      return finder.hasMutation;
+    }
+
+    return false;
+  }
+
+  bool _returnsValue(String returnType, FunctionBody? body) {
+    // void or Future<void> don't return values
+    if (returnType.isEmpty ||
+        returnType == 'void' ||
+        returnType == 'Future<void>') {
+      return false;
+    }
+
+    // Check if body has non-void return statements
+    if (body is BlockFunctionBody) {
+      final finder = _ReturnFinder();
+      body.block.accept(finder);
+      return finder.hasNonVoidReturn;
+    }
+
+    // Expression body always returns something
+    if (body is ExpressionFunctionBody) {
+      return true;
+    }
+
+    return returnType.isNotEmpty && returnType != 'void';
+  }
+}
+
+class _StateMutationFinder extends RecursiveAstVisitor<void> {
+  bool hasMutation = false;
+
+  @override
+  void visitAssignmentExpression(AssignmentExpression node) {
+    // Check if it's a field assignment (this.x = ..., _x = ...)
+    final target = node.leftHandSide;
+    if (target is PrefixedIdentifier || target is PropertyAccess) {
+      hasMutation = true;
+    } else if (target is SimpleIdentifier) {
+      final name = target.name;
+      if (name.startsWith('_') || name.startsWith('this.')) {
+        hasMutation = true;
+      }
+    }
+    super.visitAssignmentExpression(node);
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final methodName = node.methodName.name.toLowerCase();
+    // Check for mutation method calls
+    final mutationMethods = {
+      'add', 'remove', 'clear', 'insert', 'update', 'delete',
+      'push', 'pop', 'shift', 'unshift', 'splice',
+      'save', 'store', 'persist', 'write',
+    };
+    if (mutationMethods.contains(methodName)) {
+      hasMutation = true;
+    }
+    super.visitMethodInvocation(node);
+  }
+}
+
+class _ReturnFinder extends RecursiveAstVisitor<void> {
+  bool hasNonVoidReturn = false;
+
+  @override
+  void visitReturnStatement(ReturnStatement node) {
+    if (node.expression != null) {
+      hasNonVoidReturn = true;
+    }
+    super.visitReturnStatement(node);
+  }
+}
+
+extension StringExtension on String {
+  String capitalize() {
+    if (isEmpty) return this;
+    return '${this[0].toUpperCase()}${substring(1)}';
+  }
+}

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

@@ -0,0 +1,225 @@
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/source/line_info.dart';
+
+import '../../models/rule.dart';
+import '../../models/violation.dart';
+import '../base_analyzer.dart';
+
+/// C013: No Dead Code
+/// Detect and eliminate dead code including unreachable statements
+class C013NoDeadCodeAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C013';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _DeadCodeVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _DeadCodeVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C013NoDeadCodeAnalyzer analyzer;
+
+  // Track const/final boolean variables and their values
+  final Map<String, bool> _constantBooleans = {};
+
+  _DeadCodeVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
+    // Track const/final boolean variables
+    if (node.variables.isConst || node.variables.isFinal) {
+      for (final variable in node.variables.variables) {
+        final initializer = variable.initializer;
+        if (initializer is BooleanLiteral) {
+          _constantBooleans[variable.name.lexeme] = initializer.value;
+        }
+      }
+    }
+    super.visitVariableDeclarationStatement(node);
+  }
+
+  @override
+  void visitBlock(Block node) {
+    bool foundTerminator = false;
+    Statement? terminatorStatement;
+
+    for (final statement in node.statements) {
+      if (foundTerminator) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, statement.offset),
+          column: analyzer.getColumn(lineInfo, statement.offset),
+          message:
+              'Unreachable code after ${_getTerminatorName(terminatorStatement!)}',
+          metadata: {
+            'issue': 'unreachable_code',
+            'terminator': _getTerminatorName(terminatorStatement),
+          },
+        ));
+        break; // Only report once per block
+      }
+
+      if (_isTerminator(statement)) {
+        foundTerminator = true;
+        terminatorStatement = statement;
+      }
+    }
+
+    super.visitBlock(node);
+  }
+
+  @override
+  void visitIfStatement(IfStatement node) {
+    final condition = node.expression;
+
+    // Check for constant true condition
+    if (_isConstantTrue(condition)) {
+      if (node.elseStatement != null) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.elseStatement!.offset),
+          column: analyzer.getColumn(lineInfo, node.elseStatement!.offset),
+          message: 'Unreachable code block',
+          metadata: {
+            'issue': 'unreachable_code',
+            'reason': 'condition is always true',
+          },
+        ));
+      }
+    }
+
+    // Check for constant false condition
+    if (_isConstantFalse(condition)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.thenStatement.offset),
+        column: analyzer.getColumn(lineInfo, node.thenStatement.offset),
+        message: 'Unreachable code block',
+        metadata: {
+          'issue': 'unreachable_code',
+          'reason': 'condition is always false',
+        },
+      ));
+    }
+
+    super.visitIfStatement(node);
+  }
+
+  bool _isConstantTrue(Expression expr) {
+    if (expr is BooleanLiteral) return expr.value;
+    if (expr is SimpleIdentifier) {
+      // Check our tracked constant booleans
+      if (_constantBooleans.containsKey(expr.name)) {
+        return _constantBooleans[expr.name] == true;
+      }
+
+      final element = expr.staticElement;
+
+      // Check for variable elements (local, top-level, fields)
+      if (element is VariableElement) {
+        if (element.isConst || element.isFinal) {
+          final value = element.computeConstantValue();
+          if (value != null) {
+            return value.toBoolValue() == true;
+          }
+        }
+      }
+
+      // Check for property accessors
+      if (element is PropertyAccessorElement) {
+        final variable = element.variable;
+        if (variable.isConst || variable.isFinal) {
+          final value = variable.computeConstantValue();
+          if (value != null) {
+            return value.toBoolValue() == true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  bool _isConstantFalse(Expression expr) {
+    if (expr is BooleanLiteral) return !expr.value;
+    if (expr is SimpleIdentifier) {
+      // Check our tracked constant booleans
+      if (_constantBooleans.containsKey(expr.name)) {
+        return _constantBooleans[expr.name] == false;
+      }
+
+      final element = expr.staticElement;
+
+      // Check for variable elements (local, top-level, fields)
+      if (element is VariableElement) {
+        if (element.isConst || element.isFinal) {
+          final value = element.computeConstantValue();
+          if (value != null) {
+            return value.toBoolValue() == false;
+          }
+        }
+      }
+
+      // Check for property accessors
+      if (element is PropertyAccessorElement) {
+        final variable = element.variable;
+        if (variable.isConst || variable.isFinal) {
+          final value = variable.computeConstantValue();
+          if (value != null) {
+            return value.toBoolValue() == false;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  bool _isTerminator(Statement statement) {
+    if (statement is ReturnStatement) return true;
+    if (statement is ThrowExpression) return true;
+    if (statement is BreakStatement) return true;
+    if (statement is ContinueStatement) return true;
+    if (statement is ExpressionStatement) {
+      final expr = statement.expression;
+      if (expr is ThrowExpression) return true;
+    }
+    return false;
+  }
+
+  String _getTerminatorName(Statement statement) {
+    if (statement is ReturnStatement) return 'return';
+    if (statement is ThrowExpression) return 'throw';
+    if (statement is BreakStatement) return 'break';
+    if (statement is ContinueStatement) return 'continue';
+    if (statement is ExpressionStatement) {
+      if (statement.expression is ThrowExpression) return 'throw';
+    }
+    return 'terminator';
+  }
+}

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

@@ -0,0 +1,249 @@
+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';
+
+/// C014: Dependency Injection
+/// Use dependency injection instead of hardcoded dependencies
+class C014DependencyInjectionAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C014';
+
+  /// Patterns that indicate infrastructure dependencies
+  static final Set<String> infraPatterns = {
+    'Client',
+    'Repository',
+    'Service',
+    'Gateway',
+    'Adapter',
+    'Provider',
+    'Factory',
+    'Manager',
+    'Handler',
+    'Controller',
+    'Processor',
+    'Validator',
+    'Logger',
+    'Formatter',
+  };
+
+  /// Allowed built-in types
+  static final Set<String> allowedBuiltins = {
+    'DateTime',
+    'Duration',
+    'List',
+    'Map',
+    'Set',
+    'String',
+    'int',
+    'double',
+    'bool',
+    'Object',
+    'dynamic',
+    'Future',
+    'Stream',
+    'StreamController',
+    'Completer',
+    'Timer',
+  };
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _DependencyInjectionVisitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _DependencyInjectionVisitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C014DependencyInjectionAnalyzer analyzer;
+  String? currentClassName;
+
+  _DependencyInjectionVisitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    currentClassName = node.name.lexeme;
+    super.visitClassDeclaration(node);
+    currentClassName = null;
+  }
+
+  @override
+  void visitFieldDeclaration(FieldDeclaration node) {
+    // Check field initializers
+    for (final variable in node.fields.variables) {
+      if (variable.initializer != null) {
+        variable.initializer!.accept(_InstantiationFinder(
+          filePath: filePath,
+          lineInfo: lineInfo,
+          violations: violations,
+          analyzer: analyzer,
+          context: 'field initializer',
+        ));
+      }
+    }
+    super.visitFieldDeclaration(node);
+  }
+
+  @override
+  void visitConstructorDeclaration(ConstructorDeclaration node) {
+    // Check initializer list
+    for (final initializer in node.initializers) {
+      initializer.accept(_InstantiationFinder(
+        filePath: filePath,
+        lineInfo: lineInfo,
+        violations: violations,
+        analyzer: analyzer,
+        context: 'constructor initializer',
+      ));
+    }
+    
+    // Check for direct instantiation in constructor body
+    if (node.body is BlockFunctionBody) {
+      final body = node.body as BlockFunctionBody;
+      body.block.accept(_InstantiationFinder(
+        filePath: filePath,
+        lineInfo: lineInfo,
+        violations: violations,
+        analyzer: analyzer,
+        context: 'constructor',
+      ));
+    }
+    super.visitConstructorDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Skip if method is a factory or builder
+    final name = node.name.lexeme.toLowerCase();
+    if (name.startsWith('create') ||
+        name.startsWith('build') ||
+        name.startsWith('make') ||
+        name.contains('factory')) {
+      return;
+    }
+
+    if (node.body is BlockFunctionBody) {
+      final body = node.body as BlockFunctionBody;
+      body.block.accept(_InstantiationFinder(
+        filePath: filePath,
+        lineInfo: lineInfo,
+        violations: violations,
+        analyzer: analyzer,
+        context: 'method',
+      ));
+    }
+    super.visitMethodDeclaration(node);
+  }
+}
+
+class _InstantiationFinder extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C014DependencyInjectionAnalyzer analyzer;
+  final String context;
+
+  _InstantiationFinder({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+    required this.context,
+  });
+
+  @override
+  void visitInstanceCreationExpression(InstanceCreationExpression node) {
+    final typeName = node.constructorName.type.name2.lexeme;
+    _checkInfraType(typeName, node.offset);
+    super.visitInstanceCreationExpression(node);
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    // In Dart, constructor calls without 'new' keyword are parsed as MethodInvocation
+    // e.g., UserRepository() is a MethodInvocation, not InstanceCreationExpression
+    if (node.target == null) {
+      final methodName = node.methodName.name;
+      
+      // Check if this looks like a constructor call:
+      // - Starts with uppercase: UserRepository()
+      // - Starts with underscore + uppercase: _PrivateClass()
+      // NOT:
+      // - Starts with lowercase: getData()
+      // - Starts with underscore + lowercase: _updateProvider()
+      if (methodName.isNotEmpty) {
+        final firstChar = methodName[0];
+        final isConstructorPattern =
+            firstChar.toUpperCase() == firstChar && firstChar != '_' ||
+                (firstChar == '_' &&
+                    methodName.length > 1 &&
+                    methodName[1].toUpperCase() == methodName[1]);
+
+        if (isConstructorPattern) {
+          _checkInfraType(methodName, node.offset);
+        }
+      }
+    }
+    super.visitMethodInvocation(node);
+  }
+
+  void _checkInfraType(String typeName, int offset) {
+    // Check if it's an infrastructure type
+    if (_isInfraType(typeName)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message:
+            'Direct instantiation of "$typeName" in $context - consider dependency injection',
+        metadata: {
+          'type': typeName,
+          'context': context,
+          'issue': 'direct_instantiation',
+        },
+      ));
+    }
+  }
+
+  bool _isInfraType(String typeName) {
+    // Skip built-in types
+    if (C014DependencyInjectionAnalyzer.allowedBuiltins.contains(typeName)) {
+      return false;
+    }
+
+    // Check if type name ends with infrastructure patterns
+    for (final pattern in C014DependencyInjectionAnalyzer.infraPatterns) {
+      if (typeName.endsWith(pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}