@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/dart/D008_avoid_long_functions.dart

@@ -0,0 +1,394 @@
+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';
+
+/// D008: Avoid Long Functions
+/// Functions should not exceed the maximum line limit
+class D008AvoidLongFunctionsAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D008';
+
+  // Default maximum lines for a function
+  static const int _defaultMaxLines = 60;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    // Get maxLines from rule config, default to 60
+    final maxLines = (rule.config['maxLines'] as int?) ?? _defaultMaxLines;
+
+    final visitor = _D008Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+      maxLines: maxLines,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D008Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D008AvoidLongFunctionsAnalyzer analyzer;
+  final int maxLines;
+
+  _D008Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+    required this.maxLines,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    final isBuildMethod = false; // Functions can't be build method
+    final isWidgetBuilder = _isWidgetBuilder(node.returnType, node.functionExpression.body);
+    
+    if (isWidgetBuilder) {
+      final logicLines = _countLogicLines(node.functionExpression.body);
+      if (logicLines <= 10) {
+        super.visitFunctionDeclaration(node);
+        return;
+      }
+      // Widget builder with too much logic - treat as long function
+    }
+    
+    _checkFunctionLength(
+      node.functionExpression.body,
+      node.name.lexeme,
+      node.offset,
+      isBuildMethod: isBuildMethod,
+      isWidgetBuilder: isWidgetBuilder,
+    );
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    final isBuildMethod = node.name.lexeme == 'build';
+    final isWidgetBuilder = _isWidgetBuilder(node.returnType, node.body) || isBuildMethod;
+    
+    if (isWidgetBuilder) {
+      final logicLines = _countLogicLines(node.body);
+      if (logicLines <= 10) {
+        super.visitMethodDeclaration(node);
+        return;
+      }
+      // Widget builder or build with too much logic - continue to check
+    }
+    
+    _checkFunctionLength(
+      node.body,
+      node.name.lexeme,
+      node.offset,
+      isBuildMethod: isBuildMethod,
+      isWidgetBuilder: isWidgetBuilder,
+    );
+    super.visitMethodDeclaration(node);
+  }
+
+  /// Check if function/method is a widget builder
+  /// Return type contains "widget" (case insensitive) OR has widget tree pattern
+  bool _isWidgetBuilder(TypeAnnotation? returnType, FunctionBody body) {
+    final hasWidgetReturnType = returnType != null &&
+        returnType.toSource().toLowerCase().contains('widget');
+
+    final hasWidgetPattern = _hasNestedCapitalizedPattern(body);
+
+    return hasWidgetReturnType || hasWidgetPattern;
+  }
+
+  /// Count lines of logic code (excluding widget construction and comments)
+  int _countLogicLines(FunctionBody body) {
+    if (body is! BlockFunctionBody) {
+      return 0;
+    }
+
+    final block = body.block;
+    final statements = block.statements;
+
+    int logicLineCount = 0;
+
+    for (final statement in statements) {
+      // Skip return statements (usually widget construction)
+      if (statement is ReturnStatement) {
+        continue;
+      }
+
+      // Check if statement is primarily widget construction
+      if (_isWidgetConstructionStatement(statement)) {
+        continue; // Skip widget construction
+      }
+
+      // Count lines for this statement
+      final startLine = analyzer.getLine(lineInfo, statement.offset);
+      final endLine = analyzer.getLine(lineInfo, statement.end);
+      final statementLines = endLine - startLine + 1;
+
+      logicLineCount += statementLines;
+    }
+
+    return logicLineCount;
+  }
+
+  /// Check if a statement is primarily widget construction
+  bool _isWidgetConstructionStatement(Statement statement) {
+    // Skip if statements that only contain return statements (early returns)
+    if (statement is IfStatement) {
+      return _isEarlyReturnIfStatement(statement);
+    }
+    
+    // Variable declarations that assign widgets
+    if (statement is VariableDeclarationStatement) {
+      final declarations = statement.variables.variables;
+      for (final decl in declarations) {
+        final initializer = decl.initializer;
+        if (initializer != null && _isWidgetExpression(initializer)) {
+          return true;
+        }
+      }
+    }
+
+    // Expression statements that are widget calls
+    if (statement is ExpressionStatement) {
+      return _isWidgetExpression(statement.expression);
+    }
+
+    return false;
+  }
+  
+  /// Check if an if statement only contains return statements (early return pattern)
+  bool _isEarlyReturnIfStatement(IfStatement ifStatement) {
+    // Check the then branch
+    final thenStatement = ifStatement.thenStatement;
+    if (!_isReturnOrWidgetBlock(thenStatement)) {
+      return false;
+    }
+    
+    // Check the else branch if it exists
+    final elseStatement = ifStatement.elseStatement;
+    if (elseStatement != null && !_isReturnOrWidgetBlock(elseStatement)) {
+      return false;
+    }
+    
+    return true;
+  }
+  
+  /// Check if a statement is a return statement or a block containing only returns
+  bool _isReturnOrWidgetBlock(Statement statement) {
+    if (statement is ReturnStatement) {
+      return true;
+    }
+    
+    if (statement is Block) {
+      final statements = statement.statements;
+      // Empty block or all statements are returns
+      return statements.isEmpty || 
+             statements.every((s) => s is ReturnStatement);
+    }
+    
+    return false;
+  }
+
+  /// Check if an expression is widget construction
+  bool _isWidgetExpression(Expression expression) {
+    if (expression is InstanceCreationExpression) {
+      final typeName = expression.constructorName.type.name2.lexeme;
+      if (typeName.isNotEmpty &&
+          _CapitalizedPatternVisitor._isCapitalized(typeName[0])) {
+        return true;
+      }
+    }
+
+    if (expression is MethodInvocation) {
+      final methodName = expression.methodName.name;
+      if (methodName.isNotEmpty &&
+          _CapitalizedPatternVisitor._isCapitalized(methodName[0])) {
+        return true;
+      }
+    }
+    
+    return false;
+  }
+  
+  /// Detect nested capitalized identifiers (Flutter widget tree pattern)
+  /// Example: Container(child: Column(children: [Text(...), Icon(...)]))
+  bool _hasNestedCapitalizedPattern(FunctionBody body) {
+    final visitor = _CapitalizedPatternVisitor();
+    body.accept(visitor);
+    
+    // If we have multiple capitalized identifiers with nesting depth >= 2
+    // it's likely a widget tree
+    return visitor.capitalizedCount >= 3 && visitor.maxNestingDepth >= 2;
+  }
+
+  void _checkFunctionLength(
+    FunctionBody body,
+    String functionName,
+    int offset, {
+    required bool isBuildMethod,
+    required bool isWidgetBuilder,
+  }) {
+    final lineCount = _countEffectiveLines(body);
+
+    if (lineCount > maxLines) {
+      String message;
+      
+      if (isBuildMethod) {
+        // Special message for build method with too much logic
+        message = 'Build method has too much logic ($lineCount lines, max $maxLines). Consider extracting logic into separate methods or widgets';
+      } else {
+        // Regular long function message
+        message = 'Function "$functionName" has $lineCount lines (max $maxLines). Consider breaking it into smaller functions';
+      }
+      
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message: message,
+      ));
+    }
+  }
+
+  int _countEffectiveLines(FunctionBody body) {
+    // For expression functions like: () => expr
+    if (body is ExpressionFunctionBody) {
+      final startLine = analyzer.getLine(lineInfo, body.expression.offset);
+      final endLine = analyzer.getLine(lineInfo, body.expression.end);
+      return endLine - startLine + 1;
+    }
+
+    // For block functions like: () { ... }
+    if (body is BlockFunctionBody) {
+      final block = body.block;
+      final statements = block.statements;
+
+      // Empty function
+      if (statements.isEmpty) {
+        return 0;
+      }
+
+      // Get first and last statement positions
+      final firstStatement = statements.first;
+      final lastStatement = statements.last;
+
+      final startLine = analyzer.getLine(lineInfo, firstStatement.offset);
+      final endLine = analyzer.getLine(lineInfo, lastStatement.end);
+
+      // Count lines from first statement to last statement (excluding opening/closing braces)
+      int totalLines = endLine - startLine + 1;
+
+      // Subtract comment lines
+      final commentLines = _countCommentLines(block, startLine, endLine);
+      
+      return totalLines - commentLines;
+    }
+
+    // Fallback: count total lines
+    final startLine = analyzer.getLine(lineInfo, body.offset);
+    final endLine = analyzer.getLine(lineInfo, body.end);
+    return endLine - startLine + 1;
+  }
+
+  int _countCommentLines(Block block, int startLine, int endLine) {
+    // Get the source code of the block
+    final source = block.toSource();
+    final lines = source.split('\n');
+    
+    int commentLineCount = 0;
+    bool inMultiLineComment = false;
+
+    for (final line in lines) {
+      final trimmed = line.trim();
+      
+      // Check for multi-line comment start
+      if (trimmed.contains('/*')) {
+        inMultiLineComment = true;
+      }
+      
+      // If in multi-line comment, count as comment line
+      if (inMultiLineComment) {
+        commentLineCount++;
+        // Check for multi-line comment end
+        if (trimmed.contains('*/')) {
+          inMultiLineComment = false;
+        }
+        continue;
+      }
+      
+      // Check for single-line comment
+      if (trimmed.startsWith('//')) {
+        commentLineCount++;
+        continue;
+      }
+      
+      // Check for inline comment (code + comment on same line)
+      // Don't count as full comment line since there's code
+    }
+
+    return commentLineCount;
+  }
+}
+
+/// Visitor to detect nested capitalized identifiers (Flutter widget pattern)
+class _CapitalizedPatternVisitor extends RecursiveAstVisitor<void> {
+  int capitalizedCount = 0;
+  int maxNestingDepth = 0;
+  int _currentDepth = 0;
+
+  @override
+  void visitInstanceCreationExpression(InstanceCreationExpression node) {
+    final typeName = node.constructorName.type.name2.lexeme;
+    
+    // Check if type name starts with uppercase (widget pattern)
+    if (typeName.isNotEmpty && _isCapitalized(typeName[0])) {
+      capitalizedCount++;
+      _currentDepth++;
+      
+      if (_currentDepth > maxNestingDepth) {
+        maxNestingDepth = _currentDepth;
+      }
+      
+      super.visitInstanceCreationExpression(node);
+      
+      _currentDepth--;
+      return;
+    }
+    
+    super.visitInstanceCreationExpression(node);
+  }
+  
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    final methodName = node.methodName.name;
+    
+    // Check if method name starts with uppercase (could be a widget builder)
+    if (methodName.isNotEmpty && _isCapitalized(methodName[0])) {
+      capitalizedCount++;
+    }
+    
+    super.visitMethodInvocation(node);
+  }
+  
+  static bool _isCapitalized(String char) {
+    return char == char.toUpperCase() && char != char.toLowerCase();
+  }
+}

package/dart_analyzer/lib/rules/dart/D009_limit_function_parameters.dart

@@ -0,0 +1,179 @@
+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';
+
+/// D009: Limit Function Parameters
+/// Functions should not have too many parameters to maintain readability
+class D009LimitFunctionParametersAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D009';
+
+  // Default maximum number of parameters
+  static const int _defaultMaxParameters = 5;
+
+  // Default: skip nullable named parameters (they have implicit null default)
+  static const bool _defaultSkipNullableNamed = true;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    // Get maxParameters from rule config, default to 5
+    final maxParameters =
+        (rule.config['maxParameters'] as int?) ?? _defaultMaxParameters;
+
+    // Get skipNullableNamedParameters from rule config, default to true
+    // Nullable named parameters have implicit null default, making them optional
+    final skipNullableNamed =
+        (rule.config['skipNullableNamedParameters'] as bool?) ??
+            _defaultSkipNullableNamed;
+
+    final visitor = _D009Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+      maxParameters: maxParameters,
+      skipNullableNamed: skipNullableNamed,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D009Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D009LimitFunctionParametersAnalyzer analyzer;
+  final int maxParameters;
+  final bool skipNullableNamed;
+
+  _D009Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+    required this.maxParameters,
+    required this.skipNullableNamed,
+  });
+
+  @override
+  void visitFunctionDeclaration(FunctionDeclaration node) {
+    final parameters = node.functionExpression.parameters;
+    if (parameters != null) {
+      _checkParameterCount(
+        parameters,
+        node.name.lexeme,
+        'Function',
+      );
+    }
+    super.visitFunctionDeclaration(node);
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    final parameters = node.parameters;
+    if (parameters != null) {
+      _checkParameterCount(
+        parameters,
+        node.name.lexeme,
+        'Method',
+      );
+    }
+    super.visitMethodDeclaration(node);
+  }
+
+  @override
+  void visitConstructorDeclaration(ConstructorDeclaration node) {
+    final parameters = node.parameters;
+    _checkParameterCount(
+      parameters,
+      node.name?.lexeme ?? '(unnamed constructor)',
+      'Constructor',
+    );
+    super.visitConstructorDeclaration(node);
+  }
+
+  void _checkParameterCount(
+    FormalParameterList parameters,
+    String name,
+    String type,
+  ) {
+    // Count parameters, excluding optional ones based on configuration
+    int paramCount = 0;
+
+    for (final param in parameters.parameters) {
+      // Check if it's a DefaultFormalParameter (can be named or positional with defaults)
+      if (param is DefaultFormalParameter) {
+        final isNamed = param.isNamed;
+        final hasExplicitDefault = param.defaultValue != null;
+
+        // Skip named parameters with explicit default values
+        if (isNamed && hasExplicitDefault) {
+          continue;
+        }
+
+        // Skip nullable named parameters if configured (they have implicit null default)
+        if (skipNullableNamed && isNamed && !hasExplicitDefault) {
+          // Check if the parameter type is nullable
+          final paramType = param.parameter;
+          if (_isNullableParameter(paramType)) {
+            continue;
+          }
+        }
+      }
+
+      paramCount++;
+    }
+
+    if (paramCount > maxParameters) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, parameters.offset),
+        column: analyzer.getColumn(lineInfo, parameters.offset),
+        message:
+            '$type "$name" has $paramCount parameters, exceeding the limit of $maxParameters. Consider refactoring or adjusting maxParameters/skipNullableNamedParameters in config if needed.',
+      ));
+    }
+  }
+
+  /// Check if a parameter is nullable (has ? in type or uses dynamic/Object?)
+  bool _isNullableParameter(NormalFormalParameter param) {
+    if (param is SimpleFormalParameter) {
+      final type = param.type;
+      if (type == null) {
+        // No type annotation, could be dynamic
+        return false;
+      }
+
+      // Check if type has question mark (e.g., String?, int?)
+      final typeSource = type.toSource();
+      return typeSource.endsWith('?');
+    }
+
+    if (param is FieldFormalParameter) {
+      final type = param.type;
+      if (type == null) {
+        // Field formal parameter without explicit type
+        return false;
+      }
+
+      final typeSource = type.toSource();
+      return typeSource.endsWith('?');
+    }
+
+    return false;
+  }
+}