@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/dart/D021_avoid_negated_boolean_checks.dart

@@ -0,0 +1,227 @@
+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';
+
+/// D021: Avoid Negated Boolean Checks
+/// Avoid inverted or negated boolean checks to improve code readability
+class D021AvoidNegatedBooleanChecksAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D021';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D021Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D021Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D021AvoidNegatedBooleanChecksAnalyzer analyzer;
+
+  _D021Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitIfStatement(IfStatement node) {
+    final condition = node.expression;
+    
+    // Check for negated condition patterns
+    if (condition is PrefixExpression && condition.operator.lexeme == '!') {
+      final operand = condition.operand;
+      
+      // Pattern 1: Double negation - if (!(!isValid))
+      if (operand is PrefixExpression && operand.operator.lexeme == '!') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, condition.offset),
+          column: analyzer.getColumn(lineInfo, condition.offset),
+          message: 'Avoid double negation. Use positive condition instead: if (${operand.operand})',
+        ));
+      }
+      // Pattern 2: Negated parenthesized expression - if (!(condition))
+      else if (operand is ParenthesizedExpression) {
+        final inner = operand.expression;
+        
+        // Check for negated comparison that can use complementary operator
+        if (inner is BinaryExpression) {
+          final suggestion = _getComplementarySuggestion(inner);
+          if (suggestion != null) {
+            violations.add(analyzer.createViolation(
+              filePath: filePath,
+              line: analyzer.getLine(lineInfo, condition.offset),
+              column: analyzer.getColumn(lineInfo, condition.offset),
+              message: 'Use complementary operator instead: if ($suggestion)',
+            ));
+          }
+        }
+        // Negated compound condition - if (!(a && b))
+        else if (inner is BinaryExpression && 
+                 (inner.operator.lexeme == '&&' || inner.operator.lexeme == '||')) {
+          violations.add(analyzer.createViolation(
+            filePath: filePath,
+            line: analyzer.getLine(lineInfo, condition.offset),
+            column: analyzer.getColumn(lineInfo, condition.offset),
+            message: 'Simplify negated compound condition using De Morgan\'s law. Instead of !(a && b), use !a || !b',
+          ));
+        }
+      }
+      // Pattern 3: Negated boolean variable/method with negative name - if (!isError)
+      // BUT: Skip state management patterns (isError, isLoading, etc. from state objects)
+      else if (operand is SimpleIdentifier || operand is MethodInvocation || operand is PrefixedIdentifier) {
+        final name = _getIdentifierName(operand);
+        
+        // Check if this is a state property access (e.g., state.isError, asyncValue.isLoading)
+        final isStateProperty = operand is PrefixedIdentifier || 
+                                (operand is PropertyAccess);
+        
+        if (name != null && _hasNegativePrefix(name) && !_isStateManagementProperty(name, isStateProperty)) {
+          violations.add(analyzer.createViolation(
+            filePath: filePath,
+            line: analyzer.getLine(lineInfo, condition.offset),
+            column: analyzer.getColumn(lineInfo, condition.offset),
+            message: 'Replace negative with positive. Instead of !$name, consider using a positive boolean like is${_getPositiveCounterpart(name)}',
+          ));
+        }
+      }
+    }
+    
+    super.visitIfStatement(node);
+  }
+
+  @override
+  void visitPrefixExpression(PrefixExpression node) {
+    // Check for negated boolean literals or identifiers outside of if statements
+    if (node.operator.lexeme == '!' && node.parent is! IfStatement) {
+      final operand = node.operand;
+      
+      // Check for double negation in general expressions
+      if (operand is PrefixExpression && operand.operator.lexeme == '!') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Avoid double negation: !!${operand.operand.toSource()}',
+        ));
+      }
+    }
+    
+    super.visitPrefixExpression(node);
+  }
+
+  /// Get complementary operator suggestion for binary expressions
+  String? _getComplementarySuggestion(BinaryExpression expr) {
+    final left = expr.leftOperand.toSource();
+    final right = expr.rightOperand.toSource();
+    final op = expr.operator.lexeme;
+    
+    switch (op) {
+      case '==':
+        return '$left != $right';
+      case '!=':
+        return '$left == $right';
+      case '>':
+        return '$left <= $right';
+      case '<':
+        return '$left >= $right';
+      case '>=':
+        return '$left < $right';
+      case '<=':
+        return '$left > $right';
+      default:
+        return null;
+    }
+  }
+
+  /// Get identifier name from various expression types
+  String? _getIdentifierName(Expression expr) {
+    if (expr is SimpleIdentifier) {
+      return expr.name;
+    } else if (expr is PrefixedIdentifier) {
+      return expr.identifier.name;
+    } else if (expr is MethodInvocation) {
+      return expr.methodName.name;
+    }
+    return null;
+  }
+
+  /// Check if identifier has negative prefix
+  bool _hasNegativePrefix(String name) {
+    return name.startsWith('isNot') ||
+           name.startsWith('isIn') && name.contains('valid') ||
+           name.startsWith('isError') ||
+           name.startsWith('isFail') ||
+           name.startsWith('isInvalid') ||
+           name.startsWith('isDisabled') ||
+           name.startsWith('isEmpty') ||
+           name.startsWith('isAbsent') ||
+           name.startsWith('isMissing') ||
+           name.startsWith('hasNo');
+  }
+
+  /// Check if this is a state management property that should not be flagged
+  /// State management patterns (Riverpod, BLoC, etc.) often have multiple states
+  /// where !isError doesn't mean isSuccess (could be isLoading)
+  bool _isStateManagementProperty(String name, bool isPropertyAccess) {
+    // If it's a property access (state.isError, asyncValue.isLoading), check if it's a common state property
+    if (isPropertyAccess) {
+      // Common state management properties that legitimately use multiple states
+      return name == 'isError' ||
+             name == 'isLoading' ||
+             name == 'isEmpty' ||  // List/collection state
+             name == 'isFailed' ||
+             name == 'isRefreshing' ||
+             name == 'isReloading';
+    }
+    return false;
+  }
+
+  /// Get positive counterpart suggestion
+  String _getPositiveCounterpart(String name) {
+    if (name.startsWith('isNot')) {
+      return name.substring(5); // Remove 'isNot'
+    } else if (name.startsWith('isError')) {
+      return 'Success';
+    } else if (name.startsWith('isFail')) {
+      return 'Success';
+    } else if (name.startsWith('isInvalid')) {
+      return 'Valid';
+    } else if (name.startsWith('isDisabled')) {
+      return 'Enabled';
+    } else if (name.startsWith('isEmpty')) {
+      return 'NotEmpty';
+    } else if (name.startsWith('isAbsent')) {
+      return 'Present';
+    } else if (name.startsWith('isMissing')) {
+      return 'Available';
+    } else if (name.startsWith('hasNo')) {
+      return 'Has${name.substring(5)}'; // Remove 'hasNo'
+    }
+    return 'Positive';
+  }
+}

package/dart_analyzer/lib/rules/dart/D022_use_setstate_correctly.dart

@@ -0,0 +1,269 @@
+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';
+
+/// D022: Use setState Correctly
+/// Ensure setState is used correctly in StatefulWidget without common anti-patterns
+class D022UseSetStateCorrectlyAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D022';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D022Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D022Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D022UseSetStateCorrectlyAnalyzer analyzer;
+
+  // Track current method context
+  int _setStateDepth = 0;
+  final Map<int, List<MethodInvocation>> _setStateCallsByScope = {}; // Track setState nodes by scope
+  int _currentScopeId = 0;
+  final List<int> _scopeStack = []; // Stack of scope IDs
+
+  _D022Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Enter new scope for method body
+    _currentScopeId++;
+    final scopeId = _currentScopeId;
+    _scopeStack.add(scopeId);
+    _setStateCallsByScope[scopeId] = [];
+    
+    super.visitMethodDeclaration(node);
+    
+    // Exit scope - check for sequential setState calls
+    final setStateCalls = _setStateCallsByScope[scopeId] ?? [];
+    if (setStateCalls.length > 1) {
+      _checkSequentialSetStateCalls(setStateCalls);
+    }
+    
+    _scopeStack.removeLast();
+    _setStateCallsByScope.remove(scopeId);
+  }
+
+  @override
+  void visitFunctionExpression(FunctionExpression node) {
+    // Enter new scope (callback function)
+    _currentScopeId++;
+    final scopeId = _currentScopeId;
+    _scopeStack.add(scopeId);
+    _setStateCallsByScope[scopeId] = [];
+    
+    // When entering setState callback, check its body
+    if (node.parent is ArgumentList) {
+      final parent = node.parent as ArgumentList;
+      if (parent.parent is MethodInvocation) {
+        final methodInvocation = parent.parent as MethodInvocation;
+        if (methodInvocation.methodName.name == 'setState') {
+          // Check if setState callback contains async operations
+          _checkAsyncOperationsInSetState(node, methodInvocation);
+        }
+      }
+    }
+    
+    super.visitFunctionExpression(node);
+    
+    // Exit scope - check for sequential setState calls
+    final setStateCalls = _setStateCallsByScope[scopeId] ?? [];
+    if (setStateCalls.length > 1) {
+      // Check if setState calls are sequential (no control flow between them)
+      _checkSequentialSetStateCalls(setStateCalls);
+    }
+    
+    _scopeStack.removeLast();
+    _setStateCallsByScope.remove(scopeId);
+  }
+
+  /// Check if setState calls are sequential (in a row, not in different conditionals)
+  void _checkSequentialSetStateCalls(List<MethodInvocation> setStateCalls) {
+    // Group setState calls by their immediate parent block
+    final Map<Block, List<MethodInvocation>> callsByBlock = {};
+    
+    for (final call in setStateCalls) {
+      // Find the enclosing statement (ExpressionStatement)
+      AstNode? current = call;
+      while (current != null && current is! Statement) {
+        current = current.parent;
+      }
+      
+      if (current == null) continue;
+      
+      // Get the parent block
+      final blockParent = current.parent;
+      if (blockParent is! Block) continue;
+      
+      // Check if this statement is inside a conditional branch
+      // by walking up and seeing if we hit a control flow before the block
+      bool isInConditionalBranch = false;
+      AstNode? node = current;
+      
+      while (node != null && node != blockParent) {
+        final parent = node.parent;
+        
+        // If the node is the body/then/else of a control structure, it's conditional
+        if (parent is IfStatement && (node == parent.thenStatement || node == parent.elseStatement)) {
+          isInConditionalBranch = true;
+          break;
+        }
+        if (parent is SwitchCase && node == parent.statements) {
+          isInConditionalBranch = true;
+          break;
+        }
+        if (parent is TryStatement && (node == parent.body || node == parent.finallyBlock)) {
+          isInConditionalBranch = true;
+          break;
+        }
+        if (parent is WhileStatement && node == parent.body) {
+          isInConditionalBranch = true;
+          break;
+        }
+        if (parent is ForStatement && node == parent.body) {
+          isInConditionalBranch = true;
+          break;
+        }
+        if (parent is DoStatement && node == parent.body) {
+          isInConditionalBranch = true;
+          break;
+        }
+        
+        node = parent;
+      }
+      
+      if (!isInConditionalBranch) {
+        callsByBlock.putIfAbsent(blockParent, () => []).add(call);
+      }
+    }
+    
+    // Flag blocks that have 2+ sequential setState calls - report once with all line numbers
+    for (final entry in callsByBlock.entries) {
+      if (entry.value.length > 1) {
+        // Sort by line number
+        final sortedCalls = entry.value.toList()
+          ..sort((a, b) => a.offset.compareTo(b.offset));
+        
+        // Get all line numbers
+        final lineNumbers = sortedCalls
+            .map((call) => analyzer.getLine(lineInfo, call.offset))
+            .join(', ');
+        
+        // Report only at the first setState location with all line numbers
+        final firstCall = sortedCalls.first;
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, firstCall.offset),
+          column: analyzer.getColumn(lineInfo, firstCall.offset),
+          message: 'Multiple setState calls detected in sequence at lines $lineNumbers. Consider combining them into a single setState call for better performance.',
+        ));
+      }
+    }
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final methodName = node.methodName.name;
+
+    // Check for setState calls
+    if (methodName == 'setState') {
+      // Pattern: Nested setState (setState inside setState)
+      _setStateDepth++;
+      final isNestedSetState = _setStateDepth > 1;
+      
+      if (isNestedSetState) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message: 'Avoid nested setState calls. This can cause unnecessary rebuilds and makes state management harder to track.',
+        ));
+      } else {
+        // Only track top-level setState calls for multiple calls detection
+        // Track in current scope (not nested setState)
+        if (_scopeStack.isNotEmpty) {
+          final currentScope = _scopeStack.last;
+          _setStateCallsByScope[currentScope]?.add(node);
+        }
+      }
+
+      // Visit the callback to check for nested setState
+      super.visitMethodInvocation(node);
+      
+      _setStateDepth--;
+    } else {
+      super.visitMethodInvocation(node);
+    }
+  }
+
+  /// Check for async operations inside setState callback
+  void _checkAsyncOperationsInSetState(FunctionExpression callback, MethodInvocation setStateCall) {
+    // Check if callback is async
+    if (callback.body is BlockFunctionBody) {
+      final body = callback.body as BlockFunctionBody;
+      
+      // Check for async keyword
+      if (body.keyword?.lexeme == 'async') {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, setStateCall.offset),
+          column: analyzer.getColumn(lineInfo, setStateCall.offset),
+          message: 'Avoid async callbacks in setState. setState should only update state synchronously. Perform async operations before calling setState.',
+        ));
+      }
+
+      // Check for await expressions in the body
+      final awaitChecker = _AwaitExpressionChecker();
+      body.block.accept(awaitChecker);
+      
+      if (awaitChecker.hasAwait) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, setStateCall.offset),
+          column: analyzer.getColumn(lineInfo, setStateCall.offset),
+          message: 'setState callback contains await expression. Perform async operations outside setState and only update state synchronously.',
+        ));
+      }
+    }
+  }
+}
+
+/// Helper visitor to check for await expressions
+class _AwaitExpressionChecker extends RecursiveAstVisitor<void> {
+  bool hasAwait = false;
+
+  @override
+  void visitAwaitExpression(AwaitExpression node) {
+    hasAwait = true;
+    super.visitAwaitExpression(node);
+  }
+}

package/dart_analyzer/lib/rules/dart/D023_avoid_unnecessary_method_overrides.dart

@@ -0,0 +1,191 @@
+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';
+
+/// D023: Avoid Unnecessary Method Overrides
+/// Methods that only call super with the same parameters are unnecessary
+class D023AvoidUnnecessaryMethodOverridesAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D023';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D023Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D023Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D023AvoidUnnecessaryMethodOverridesAnalyzer analyzer;
+
+  _D023Visitor({
+    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((annotation) {
+      return annotation.name.name == 'override';
+    });
+
+    if (!hasOverride) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    // Check if method body only contains a super call
+    final body = node.body;
+    if (body is! BlockFunctionBody) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    final statements = body.block.statements;
+    
+    // Method must have exactly one statement
+    if (statements.length != 1) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    final statement = statements.first;
+    ExpressionStatement? expressionStatement;
+
+    // Handle both ExpressionStatement and ReturnStatement
+    if (statement is ExpressionStatement) {
+      expressionStatement = statement;
+    } else if (statement is ReturnStatement) {
+      // Check if return statement returns a super call
+      final returnExpression = statement.expression;
+      if (returnExpression is! MethodInvocation) {
+        super.visitMethodDeclaration(node);
+        return;
+      }
+      
+      final methodInvocation = returnExpression;
+      if (!_isSuperCall(methodInvocation, node.name.lexeme)) {
+        super.visitMethodDeclaration(node);
+        return;
+      }
+      
+      // Check if parameters match
+      if (_parametersMatch(node, methodInvocation)) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.name.offset),
+          column: analyzer.getColumn(lineInfo, node.name.offset),
+          message: 'Method "${node.name.lexeme}" only calls super.${node.name.lexeme}() with the same parameters. This override is unnecessary and can be removed.',
+        ));
+      }
+      
+      super.visitMethodDeclaration(node);
+      return;
+    } else {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    // Get the expression from ExpressionStatement
+    final expression = expressionStatement.expression;
+    if (expression is! MethodInvocation) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    final methodInvocation = expression;
+
+    // Check if it's a super call to the same method
+    if (!_isSuperCall(methodInvocation, node.name.lexeme)) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    // Check if parameters match
+    if (_parametersMatch(node, methodInvocation)) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.name.offset),
+        column: analyzer.getColumn(lineInfo, node.name.offset),
+        message: 'Method "${node.name.lexeme}" only calls super.${node.name.lexeme}() with the same parameters. This override is unnecessary and can be removed.',
+      ));
+    }
+
+    super.visitMethodDeclaration(node);
+  }
+
+  /// Check if method invocation is a super call to the same method
+  bool _isSuperCall(MethodInvocation invocation, String methodName) {
+    final target = invocation.target;
+    if (target is! SuperExpression) return false;
+    
+    return invocation.methodName.name == methodName;
+  }
+
+  /// Check if the parameters in the super call match the method parameters
+  bool _parametersMatch(MethodDeclaration method, MethodInvocation superCall) {
+    final methodParams = method.parameters?.parameters ?? [];
+    final superArgs = superCall.argumentList.arguments;
+
+    // Number of arguments must match
+    if (methodParams.length != superArgs.length) return false;
+
+    // Check each argument
+    for (var i = 0; i < methodParams.length; i++) {
+      final param = methodParams[i];
+      final arg = superArgs[i];
+
+      // Get parameter name
+      String? paramName;
+      if (param is SimpleFormalParameter) {
+        paramName = param.name?.lexeme;
+      } else if (param is DefaultFormalParameter) {
+        final innerParam = param.parameter;
+        if (innerParam is SimpleFormalParameter) {
+          paramName = innerParam.name?.lexeme;
+        }
+      }
+
+      // Check if argument is a simple identifier matching parameter name
+      if (arg is NamedExpression) {
+        // For named arguments, check both name and value
+        final argValue = arg.expression;
+        if (argValue is! SimpleIdentifier) return false;
+        if (argValue.name != paramName) return false;
+      } else if (arg is SimpleIdentifier) {
+        // For positional arguments, check if identifier matches parameter
+        if (arg.name != paramName) return false;
+      } else {
+        // Any other expression type means parameters don't simply match
+        return false;
+      }
+    }
+
+    return true;
+  }
+}