@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/dart/D004_avoid_shrinkwrap_listview.dart

@@ -0,0 +1,154 @@
+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';
+
+/// D004: Avoid shrinkWrap in ListView
+/// ListView with shrinkWrap: true causes performance issues by disabling lazy loading
+/// and forcing all items to render at once. Use Expanded/Flexible or SliverList instead.
+class D004AvoidShrinkwrapListviewAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D004';
+
+  // Widget types to check for shrinkWrap usage
+  static const _scrollableWidgets = [
+    'ListView',
+    'GridView',
+    'ListView.builder',
+    'ListView.separated',
+    'GridView.builder',
+    'GridView.count',
+    'GridView.extent',
+  ];
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D004Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D004Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D004AvoidShrinkwrapListviewAnalyzer analyzer;
+
+  _D004Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    // Handle named constructors like ListView.builder, GridView.count, etc.
+    // In Dart AST, these are MethodInvocation nodes, not InstanceCreationExpression
+    final target = node.target;
+    final methodName = node.methodName.name;
+    
+    if (target != null) {
+      final targetName = target.toString();
+      final fullName = '$targetName.$methodName';
+      
+      if (_isScrollableWidget(fullName) || _isScrollableWidget(targetName)) {
+        _checkForShrinkWrap(node.argumentList, fullName);
+      }
+    }
+
+    super.visitMethodInvocation(node);
+  }
+
+  @override
+  void visitInstanceCreationExpression(InstanceCreationExpression node) {
+    final typeName = node.constructorName.type.toSource();
+    // Check if this is a ListView or GridView construction
+    if (_isScrollableWidget(typeName)) {
+      _checkForShrinkWrap(node.argumentList, typeName);
+    }
+
+    super.visitInstanceCreationExpression(node);
+  }
+
+  /// Check for shrinkWrap parameter in argument list
+  void _checkForShrinkWrap(ArgumentList argumentList, String widgetName) {
+    final arguments = argumentList.arguments;
+    for (final arg in arguments) {
+      if (arg is NamedExpression) {
+        final paramName = arg.name.label.name;
+        if (paramName == 'shrinkWrap') {
+          // Check if the value is true
+          final expression = arg.expression;
+          
+          if (_isTrueValue(expression)) {
+            violations.add(analyzer.createViolation(
+              filePath: filePath,
+              line: analyzer.getLine(lineInfo, arg.offset),
+              column: analyzer.getColumn(lineInfo, arg.offset),
+              message: 'Avoid using shrinkWrap: true in $widgetName. '
+                  'It disables lazy loading and forces all items to render at once, '
+                  'causing performance issues. Use Expanded/Flexible widget or SliverList instead.',
+            ));
+          }
+        }
+      }
+    }
+  }
+
+  /// Check if the type name matches a scrollable widget
+  bool _isScrollableWidget(String typeName) {
+    return D004AvoidShrinkwrapListviewAnalyzer._scrollableWidgets.any(
+      (widget) => typeName.startsWith(widget),
+    );
+  }
+
+  /// Check if an expression evaluates to true
+  bool _isTrueValue(Expression expression) {
+    // Direct boolean literal: true
+    if (expression is BooleanLiteral) {
+      return expression.value;
+    }
+    
+    // Simple identifier: could be a constant or variable
+    // We flag it as potential violation to be safe
+    if (expression is SimpleIdentifier) {
+      final name = expression.name;
+      // Common patterns for true values
+      if (name == 'true' || name.toLowerCase().contains('true')) {
+        return true;
+      }
+    }
+    
+    // Prefix expression: !false
+    if (expression is PrefixExpression) {
+      if (expression.operator.lexeme == '!') {
+        // If it's !false, that's true
+        if (expression.operand is BooleanLiteral) {
+          final literal = expression.operand as BooleanLiteral;
+          return !literal.value;
+        }
+      }
+    }
+    
+    return false;
+  }
+}

package/dart_analyzer/lib/rules/dart/D005_limit_widget_nesting.dart

@@ -0,0 +1,265 @@
+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';
+
+/// D005: Limit Widget Nesting Depth
+/// Widget nesting should not exceed 6 levels to maintain code readability and performance.
+/// Deeply nested widgets make code harder to understand and can impact performance.
+class D005LimitWidgetNestingAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D005';
+
+  static const int _maxNestingDepth = 6;
+
+  // Common widget types to check for nesting
+  static const _widgetTypes = [
+    'Container',
+    'Column',
+    'Row',
+    'Stack',
+    'Scaffold',
+    'Card',
+    'Padding',
+    'Center',
+    'Align',
+    'Expanded',
+    'Flexible',
+    'SizedBox',
+    'ListView',
+    'GridView',
+    'SingleChildScrollView',
+    'CustomScrollView',
+    'Wrap',
+    'AnimatedContainer',
+    'DecoratedBox',
+    'Transform',
+    'Positioned',
+    'SafeArea',
+    'Material',
+    'InkWell',
+    'GestureDetector',
+    'Text',
+    'Icon',
+    'Image',
+    'CircleAvatar',
+    'TextField',
+    'Button',
+    'ElevatedButton',
+    'TextButton',
+    'OutlinedButton',
+    'IconButton',
+    'FloatingActionButton',
+    'AppBar',
+    'BottomNavigationBar',
+    'Drawer',
+    'ListTile',
+    'CheckboxListTile',
+    'RadioListTile',
+    'SwitchListTile',
+    'Chip',
+    'InputChip',
+    'ChoiceChip',
+    'FilterChip',
+    'ActionChip',
+    'Tooltip',
+    'Banner',
+    'SnackBar',
+    'Dialog',
+    'AlertDialog',
+    'SimpleDialog',
+    'BottomSheet',
+    'DatePicker',
+    'TimePicker',
+    'Slider',
+    'Switch',
+    'Checkbox',
+    'Radio',
+    'DropdownButton',
+    'PopupMenuButton',
+    'Tab',
+    'TabBar',
+    'TabBarView',
+    'Stepper',
+    'Step',
+    'ExpansionPanel',
+    'ExpansionTile',
+  ];
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D005Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D005Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D005LimitWidgetNestingAnalyzer analyzer;
+
+  _D005Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  // Track widget nesting depth for each build method
+  int _currentDepth = 0;
+  int _maxDepthInCurrentMethod = 0;
+  bool _insideBuildMethod = false;
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Check if this is a build method
+    if (node.name.lexeme == 'build') {
+      // Reset counters for new build method
+      _currentDepth = 0;
+      _maxDepthInCurrentMethod = 0;
+      _insideBuildMethod = true;
+
+      // Visit the method body
+      super.visitMethodDeclaration(node);
+
+      _insideBuildMethod = false;
+
+      // Check if max depth exceeded
+      if (_maxDepthInCurrentMethod > D005LimitWidgetNestingAnalyzer._maxNestingDepth) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.name.offset),
+          column: analyzer.getColumn(lineInfo, node.name.offset),
+          message:
+              'Widget nesting depth is $_maxDepthInCurrentMethod, which exceeds the maximum of ${D005LimitWidgetNestingAnalyzer._maxNestingDepth}. '
+              'Consider extracting nested widgets into separate widget classes to improve readability and maintainability.',
+        ));
+      }
+    } else {
+      super.visitMethodDeclaration(node);
+    }
+  }
+
+  @override
+  void visitInstanceCreationExpression(InstanceCreationExpression node) {
+    if (!_insideBuildMethod) {
+      super.visitInstanceCreationExpression(node);
+      return;
+    }
+
+    final typeName = node.constructorName.type.toSource();
+
+    // Check if this is a widget instance
+    if (_isWidget(typeName)) {
+      _currentDepth++;
+      if (_currentDepth > _maxDepthInCurrentMethod) {
+        _maxDepthInCurrentMethod = _currentDepth;
+      }
+    }
+
+    super.visitInstanceCreationExpression(node);
+
+    if (_isWidget(typeName)) {
+      _currentDepth--;
+    }
+  }
+
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (!_insideBuildMethod) {
+      super.visitMethodInvocation(node);
+      return;
+    }
+
+    final methodName = node.methodName.name;
+
+    // Handle widget constructor calls (no target, starts with uppercase)
+    // In modern Dart, widget constructors without 'new' are parsed as MethodInvocation
+    if (node.target == null) {
+      if (methodName.isNotEmpty && _isWidget(methodName)) {
+        _currentDepth++;
+        if (_currentDepth > _maxDepthInCurrentMethod) {
+          _maxDepthInCurrentMethod = _currentDepth;
+        }
+
+        super.visitMethodInvocation(node);
+
+        _currentDepth--;
+        return;
+      }
+    }
+
+    // Handle named constructors like ListView.builder, GridView.count
+    final target = node.target;
+    if (target != null) {
+      final targetName = target.toString();
+      final fullName = '$targetName.$methodName';
+
+      if (_isWidget(fullName) || _isWidget(targetName)) {
+        _currentDepth++;
+        if (_currentDepth > _maxDepthInCurrentMethod) {
+          _maxDepthInCurrentMethod = _currentDepth;
+        }
+      }
+    }
+
+    super.visitMethodInvocation(node);
+
+    if (target != null) {
+      final targetName = target.toString();
+      final fullName = '$targetName.$methodName';
+
+      if (_isWidget(fullName) || _isWidget(targetName)) {
+        _currentDepth--;
+      }
+    }
+  }
+
+  /// Check if the type name represents a widget
+  /// We check by looking at common patterns rather than exhaustive list
+  bool _isWidget(String typeName) {
+    // Known widget types from our list
+    if (D005LimitWidgetNestingAnalyzer._widgetTypes.any(
+      (widget) => typeName.startsWith(widget),
+    )) {
+      return true;
+    }
+    
+    // Additional heuristics:
+    // 1. Ends with common widget suffixes
+    if (typeName.endsWith('Widget') || 
+        typeName.endsWith('View') || 
+        typeName.endsWith('Screen') || 
+        typeName.endsWith('Page')) {
+      return true;
+    }
+    
+    // 2. Starts with common Flutter widget prefixes
+    if (typeName.startsWith('Cupertino') || 
+        typeName.startsWith('Material') ||
+        typeName.startsWith('Adaptive')) {
+      return true;
+    }
+    
+    return false;
+  }
+}

package/dart_analyzer/lib/rules/dart/D006_prefer_extracting_large_callbacks.dart

@@ -0,0 +1,135 @@
+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';
+
+/// D006: Prefer Extracting Large Callbacks from Build
+/// Large callback functions in widget builders should be extracted to separate methods
+/// for better readability and maintainability.
+class D006PreferExtractingLargeCallbacksAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D006';
+
+  static const int _maxLines = 5;
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D006Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D006Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D006PreferExtractingLargeCallbacksAnalyzer analyzer;
+
+  _D006Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  bool _insideBuildMethod = false;
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Track if we're inside a build method
+    final wasPreviouslyInsideBuild = _insideBuildMethod;
+    if (node.name.lexeme == 'build') {
+      _insideBuildMethod = true;
+    }
+
+    super.visitMethodDeclaration(node);
+
+    _insideBuildMethod = wasPreviouslyInsideBuild;
+  }
+
+  @override
+  void visitNamedExpression(NamedExpression node) {
+    if (!_insideBuildMethod) {
+      super.visitNamedExpression(node);
+      return;
+    }
+
+    final propertyName = node.name.label.name;
+    final expression = node.expression;
+
+    // Check ANY function expression (anonymous function/lambda) regardless of name
+    // This catches all inline callbacks: onTap, onPressed, custom callbacks, etc.
+    if (expression is FunctionExpression) {
+      final lineCount = _countLines(expression);
+
+      if (lineCount > D006PreferExtractingLargeCallbacksAnalyzer._maxLines) {
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.offset),
+          column: analyzer.getColumn(lineInfo, node.offset),
+          message:
+              'Inline function "$propertyName" has $lineCount lines (max ${D006PreferExtractingLargeCallbacksAnalyzer._maxLines}). '
+              'Consider extracting it to a separate method for better readability and testability.',
+        ));
+      }
+    }
+
+    super.visitNamedExpression(node);
+  }
+
+  /// Count the number of lines in a function expression
+  /// Ignores the opening and closing braces to count only actual code lines
+  int _countLines(FunctionExpression node) {
+    final body = node.body;
+    
+    // For expression functions like: () => expression
+    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;
+      
+      // If no statements, it's empty - count as 0
+      if (statements.isEmpty) {
+        return 0;
+      }
+      
+      // Count from first statement to last statement, ignoring { and }
+      final firstStatement = statements.first;
+      final lastStatement = statements.last;
+      
+      final startLine = analyzer.getLine(lineInfo, firstStatement.offset);
+      final endLine = analyzer.getLine(lineInfo, lastStatement.end);
+      
+      return endLine - startLine + 1;
+    }
+    
+    // Fallback: count total lines (shouldn't normally reach here)
+    final startLine = analyzer.getLine(lineInfo, node.offset);
+    final endLine = analyzer.getLine(lineInfo, node.end);
+    return endLine - startLine + 1;
+  }
+}

package/dart_analyzer/lib/rules/dart/D007_prefer_init_first_dispose_last.dart

@@ -0,0 +1,150 @@
+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';
+
+/// D007: Prefer Init First, Dispose Last
+/// Code should be called after super.initState() and before super.dispose()
+class D007PreferInitFirstDisposeLastAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D007';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D007Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D007Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D007PreferInitFirstDisposeLastAnalyzer analyzer;
+
+  _D007Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    final methodName = node.name.lexeme;
+    
+    if (methodName == 'initState') {
+      _checkInitState(node);
+    } else if (methodName == 'dispose') {
+      _checkDispose(node);
+    }
+
+    super.visitMethodDeclaration(node);
+  }
+
+  void _checkInitState(MethodDeclaration node) {
+    final body = node.body;
+    if (body is! BlockFunctionBody) return;
+
+    final block = body.block;
+    final statements = block.statements;
+    if (statements.isEmpty) return;
+
+    // Find super.initState() call
+    int superInitStateIndex = -1;
+    for (int i = 0; i < statements.length; i++) {
+      if (_isSuperInitStateCall(statements[i])) {
+        superInitStateIndex = i;
+        break;
+      }
+    }
+
+    // If no super.initState() found, don't check
+    if (superInitStateIndex == -1) return;
+
+    // If super.initState() is not first, report violation
+    if (superInitStateIndex > 0) {
+      final firstStatement = statements[0];
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, firstStatement.offset),
+        column: analyzer.getColumn(lineInfo, firstStatement.offset),
+        message: 'super.initState() should be called first in initState(). Move code after super.initState()',
+      ));
+    }
+  }
+
+  void _checkDispose(MethodDeclaration node) {
+    final body = node.body;
+    if (body is! BlockFunctionBody) return;
+
+    final block = body.block;
+    final statements = block.statements;
+    if (statements.isEmpty) return;
+
+    // Find super.dispose() call
+    int superDisposeIndex = -1;
+    for (int i = 0; i < statements.length; i++) {
+      if (_isSuperDisposeCall(statements[i])) {
+        superDisposeIndex = i;
+        break;
+      }
+    }
+
+    // If no super.dispose() found, don't check
+    if (superDisposeIndex == -1) return;
+
+    // If super.dispose() is not last, report violation
+    if (superDisposeIndex < statements.length - 1) {
+      final statementAfterSuper = statements[superDisposeIndex + 1];
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, statementAfterSuper.offset),
+        column: analyzer.getColumn(lineInfo, statementAfterSuper.offset),
+        message: 'super.dispose() should be called last in dispose(). Move code before super.dispose()',
+      ));
+    }
+  }
+
+  bool _isSuperInitStateCall(Statement statement) {
+    if (statement is! ExpressionStatement) return false;
+    
+    final expression = statement.expression;
+    if (expression is! MethodInvocation) return false;
+    
+    final target = expression.target;
+    if (target is! SuperExpression) return false;
+    
+    return expression.methodName.name == 'initState';
+  }
+
+  bool _isSuperDisposeCall(Statement statement) {
+    if (statement is! ExpressionStatement) return false;
+    
+    final expression = statement.expression;
+    if (expression is! MethodInvocation) return false;
+    
+    final target = expression.target;
+    if (target is! SuperExpression) return false;
+    
+    return expression.methodName.name == 'dispose';
+  }
+}