@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/dart/D010_limit_cyclomatic_complexity.dart

@@ -0,0 +1,257 @@
+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';
+
+/// D010: Limit Cyclomatic Complexity
+/// Functions should not have high cyclomatic complexity to maintain readability
+class D010LimitCyclomaticComplexityAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D010';
+
+  // Default maximum cyclomatic complexity
+  static const int _defaultMaxComplexity = 10;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    // Get maxComplexity from rule config, default to 10
+    final maxComplexity = (rule.config['maxComplexity'] as int?) ?? _defaultMaxComplexity;
+
+    final visitor = _D010Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+      maxComplexity: maxComplexity,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D010Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D010LimitCyclomaticComplexityAnalyzer analyzer;
+  final int maxComplexity;
+
+  _D010Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+    required this.maxComplexity,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    final complexity = _calculateComplexity(node.functionExpression.body);
+    if (complexity > maxComplexity) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.name.offset),
+        column: analyzer.getColumn(lineInfo, node.name.offset),
+        message: 'Function "${node.name.lexeme}" has cyclomatic complexity of $complexity, exceeding the limit of $maxComplexity',
+      ));
+    }
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    final complexity = _calculateComplexity(node.body);
+    if (complexity > maxComplexity) {
+      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}" has cyclomatic complexity of $complexity, exceeding the limit of $maxComplexity',
+      ));
+    }
+    super.visitMethodDeclaration(node);
+  }
+
+  @override
+  void visitConstructorDeclaration(ConstructorDeclaration node) {
+    final complexity = _calculateComplexity(node.body);
+    if (complexity > maxComplexity) {
+      final name = node.name?.lexeme ?? '(unnamed constructor)';
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.offset),
+        column: analyzer.getColumn(lineInfo, node.offset),
+        message: 'Constructor "$name" has cyclomatic complexity of $complexity, exceeding the limit of $maxComplexity',
+      ));
+    }
+    super.visitConstructorDeclaration(node);
+  }
+
+  /// Calculate cyclomatic complexity for a function body
+  int _calculateComplexity(FunctionBody? body) {
+    if (body == null) return 1;
+
+    final complexityVisitor = _ComplexityVisitor();
+    body.accept(complexityVisitor);
+    
+    // Cyclomatic complexity starts at 1 for the function itself
+    return 1 + complexityVisitor.complexity;
+  }
+}
+
+/// Visitor to calculate cyclomatic complexity
+class _ComplexityVisitor extends RecursiveAstVisitor<void> {
+  int complexity = 0;
+
+  @override
+  void visitIfStatement(IfStatement node) {
+    // if statement adds 1
+    complexity++;
+    super.visitIfStatement(node);
+  }
+
+  @override
+  void visitConditionalExpression(ConditionalExpression node) {
+    // ternary operator (? :) adds 1
+    complexity++;
+    super.visitConditionalExpression(node);
+  }
+
+  @override
+  void visitForStatement(ForStatement node) {
+    // for loop adds 1
+    complexity++;
+    super.visitForStatement(node);
+  }
+
+  @override
+  void visitForElement(ForElement node) {
+    // for in collection adds 1
+    complexity++;
+    super.visitForElement(node);
+  }
+
+  @override
+  void visitWhileStatement(WhileStatement node) {
+    // while loop adds 1
+    complexity++;
+    super.visitWhileStatement(node);
+  }
+
+  @override
+  void visitDoStatement(DoStatement node) {
+    // do-while loop adds 1
+    complexity++;
+    super.visitDoStatement(node);
+  }
+
+  @override
+  void visitCatchClause(CatchClause node) {
+    // catch adds 1
+    complexity++;
+    super.visitCatchClause(node);
+  }
+
+  @override
+  void visitSwitchStatement(SwitchStatement node) {
+    // Each case adds 1 (except default or last case)
+    final members = node.members;
+    if (members.isNotEmpty) {
+      // Count all SwitchCase members except the last one
+      for (int i = 0; i < members.length - 1; i++) {
+        final member = members[i];
+        // Only count SwitchCase (not SwitchDefault)
+        if (member is SwitchCase || member is SwitchPatternCase) {
+          complexity++;
+        }
+      }
+      // Don't count the last case (regardless of whether it's SwitchCase or SwitchDefault)
+    }
+    super.visitSwitchStatement(node);
+  }
+
+  @override
+  void visitSwitchExpression(SwitchExpression node) {
+    // Each case in switch expression adds 1 (except last)
+    final cases = node.cases;
+    if (cases.isNotEmpty) {
+      // All cases except the last one
+      complexity += cases.length - 1;
+    }
+    super.visitSwitchExpression(node);
+  }
+
+  @override
+  void visitBinaryExpression(BinaryExpression node) {
+    // && and || operators add 1
+    final operator = node.operator.lexeme;
+    if (operator == '&&' || operator == '||') {
+      complexity++;
+    }
+    super.visitBinaryExpression(node);
+  }
+
+  @override
+  void visitIfElement(IfElement node) {
+    // if in collection literal adds 1
+    complexity++;
+    super.visitIfElement(node);
+  }
+
+  @override
+  void visitPropertyAccess(PropertyAccess node) {
+    // Null-aware operator ?. adds 1
+    if (node.operator.lexeme == '?.') {
+      complexity++;
+    }
+    super.visitPropertyAccess(node);
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    // Null-aware operator ?. adds 1
+    if (node.operator?.lexeme == '?.') {
+      complexity++;
+    }
+    super.visitMethodInvocation(node);
+  }
+
+  @override
+  void visitIndexExpression(IndexExpression node) {
+    // Null-aware operator ?[] adds 1
+    if (node.question != null) {
+      complexity++;
+    }
+    super.visitIndexExpression(node);
+  }
+
+  @override
+  void visitSpreadElement(SpreadElement node) {
+    // Null-aware spread ...? adds 1
+    if (node.spreadOperator.lexeme == '...?') {
+      complexity++;
+    }
+    super.visitSpreadElement(node);
+  }
+
+  @override
+  void visitAssignmentExpression(AssignmentExpression node) {
+    // ??= operator adds 1
+    if (node.operator.lexeme == '??=') {
+      complexity++;
+    }
+    super.visitAssignmentExpression(node);
+  }
+}

package/dart_analyzer/lib/rules/dart/D011_prefer_named_parameters.dart

@@ -0,0 +1,152 @@
+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';
+
+/// D011: Prefer Named Parameters
+/// Functions with more than 3 parameters and adjacent parameters of the same type should use named parameters
+class D011PreferNamedParametersAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D011';
+
+  // Default minimum parameter count to trigger the check
+  static const int _defaultMinParameterCount = 3;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    // Get minParameterCount from rule config, default to 3
+    final minParameterCount = (rule.config['minParameterCount'] as int?) ?? _defaultMinParameterCount;
+
+    final visitor = _D011Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+      minParameterCount: minParameterCount,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D011Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D011PreferNamedParametersAnalyzer analyzer;
+  final int minParameterCount;
+
+  _D011Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+    required this.minParameterCount,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    _checkParameters(
+      node.functionExpression.parameters,
+      node.name.lexeme,
+      node.name.offset,
+    );
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    _checkParameters(
+      node.parameters,
+      node.name.lexeme,
+      node.name.offset,
+    );
+    super.visitMethodDeclaration(node);
+  }
+
+  @override
+  void visitConstructorDeclaration(ConstructorDeclaration node) {
+    final name = node.name?.lexeme ?? '(unnamed constructor)';
+    _checkParameters(
+      node.parameters,
+      name,
+      node.offset,
+    );
+    super.visitConstructorDeclaration(node);
+  }
+
+  void _checkParameters(FormalParameterList? parameters, String name, int offset) {
+    if (parameters == null) return;
+
+    final allParams = parameters.parameters;
+    if (allParams.length <= minParameterCount) return;
+
+    // Check if there are already named parameters
+    final hasNamedParams = allParams.any((p) => p.isNamed);
+    
+    // Get only positional parameters for checking
+    final positionalParams = allParams.where((p) => !p.isNamed).toList();
+    
+    if (positionalParams.length <= minParameterCount) return;
+
+    // Check for adjacent parameters with the same type
+    bool hasAdjacentSameType = _hasAdjacentSameTypeParameters(positionalParams);
+
+    if (hasAdjacentSameType) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message: hasNamedParams
+            ? 'Function "$name" has ${positionalParams.length} positional parameters with adjacent same-type parameters. Consider using named parameters for all non-required parameters.'
+            : 'Function "$name" has ${allParams.length} parameters with adjacent same-type parameters. Consider using named parameters.',
+      ));
+    }
+  }
+
+  bool _hasAdjacentSameTypeParameters(List<FormalParameter> params) {
+    if (params.length < 2) return false;
+
+    for (int i = 0; i < params.length - 1; i++) {
+      final currentType = _getParameterType(params[i]);
+      final nextType = _getParameterType(params[i + 1]);
+
+      // If both types are not null and they match, we have adjacent same-type parameters
+      if (currentType != null && nextType != null && currentType == nextType) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  String? _getParameterType(FormalParameter param) {
+    // Handle different parameter types
+    if (param is SimpleFormalParameter) {
+      return param.type?.toSource();
+    } else if (param is DefaultFormalParameter) {
+      final innerParam = param.parameter;
+      if (innerParam is SimpleFormalParameter) {
+        return innerParam.type?.toSource();
+      } else if (innerParam is FieldFormalParameter) {
+        return innerParam.type?.toSource();
+      }
+    } else if (param is FieldFormalParameter) {
+      return param.type?.toSource();
+    }
+
+    return null;
+  }
+}

package/dart_analyzer/lib/rules/dart/D012_prefer_named_boolean_parameters.dart

@@ -0,0 +1,156 @@
+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';
+
+/// D012: Prefer Named Boolean Parameters
+/// Boolean parameters should be named or use separate functions for better readability
+class D012PreferNamedBooleanParametersAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D012';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D012Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D012Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D012PreferNamedBooleanParametersAnalyzer analyzer;
+
+  _D012Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    _checkBooleanParameters(
+      node.functionExpression.parameters,
+      node.name.lexeme,
+      node.name.offset,
+    );
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    _checkBooleanParameters(
+      node.parameters,
+      node.name.lexeme,
+      node.name.offset,
+    );
+    super.visitMethodDeclaration(node);
+  }
+
+  @override
+  void visitConstructorDeclaration(ConstructorDeclaration node) {
+    final name = node.name?.lexeme ?? '(unnamed constructor)';
+    _checkBooleanParameters(
+      node.parameters,
+      name,
+      node.offset,
+    );
+    super.visitConstructorDeclaration(node);
+  }
+
+  void _checkBooleanParameters(FormalParameterList? parameters, String name, int offset) {
+    if (parameters == null) return;
+
+    final allParams = parameters.parameters;
+    if (allParams.isEmpty) return;
+
+    // Get positional boolean parameters
+    final positionalBools = <FormalParameter>[];
+    final positionalParams = <FormalParameter>[];
+    
+    for (final param in allParams) {
+      if (!param.isNamed) {
+        positionalParams.add(param);
+        if (_isBooleanParameter(param)) {
+          positionalBools.add(param);
+        }
+      }
+    }
+
+    if (positionalBools.isEmpty) return;
+
+    // Case 1: Single boolean parameter (or only boolean parameters)
+    if (positionalParams.length <= 2 && positionalBools.length == 1) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message: 'Function "$name" has a boolean parameter. Consider creating separate functions (e.g., ${_generateSeparateFunctionSuggestion(name)}) instead of using a boolean flag.',
+      ));
+    }
+    // Case 2: Multiple parameters with boolean(s)
+    else if (positionalBools.isNotEmpty) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message: 'Function "$name" has boolean parameter(s). Consider using named parameters for boolean values to improve readability at call sites.',
+      ));
+    }
+  }
+
+  bool _isBooleanParameter(FormalParameter param) {
+    String? typeName;
+    
+    if (param is SimpleFormalParameter) {
+      typeName = param.type?.toSource();
+    } else if (param is DefaultFormalParameter) {
+      final innerParam = param.parameter;
+      if (innerParam is SimpleFormalParameter) {
+        typeName = innerParam.type?.toSource();
+      } else if (innerParam is FieldFormalParameter) {
+        typeName = innerParam.type?.toSource();
+      }
+    } else if (param is FieldFormalParameter) {
+      typeName = param.type?.toSource();
+    }
+
+    return typeName == 'bool' || typeName == 'bool?';
+  }
+
+  String _generateSeparateFunctionSuggestion(String functionName) {
+    // Generate suggestion for separate function names
+    // e.g., "setUser" -> "enableUser/disableUser" or "setUserEnabled/setUserDisabled"
+    if (functionName.startsWith('set')) {
+      final base = functionName.substring(3);
+      return 'enable$base/disable$base';
+    } else if (functionName.startsWith('get')) {
+      final base = functionName.substring(3);
+      return 'get${base}Enabled/get${base}Disabled';
+    } else if (functionName.startsWith('is')) {
+      return functionName; // is methods are fine
+    } else {
+      return '${functionName}Enabled/${functionName}Disabled';
+    }
+  }
+}