@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/dart/D002_dispose_resources.dart

@@ -0,0 +1,338 @@
+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';
+
+/// D002: Always Dispose Resources and Remove Listeners
+/// Ensures all resources (Controllers, StreamSubscriptions, FocusNodes) are properly disposed
+/// 
+/// Important: Only checks owned resources (created locally), not external resources (from constructor)
+class D002DisposeResourcesAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D002';
+
+  // Types that require disposal (exact matches)
+  static const _disposableTypes = [
+    'Controller',
+    'StreamSubscription',
+    'FocusNode',
+    'AnimationController',
+    'TextEditingController',
+    'ScrollController',
+    'TabController',
+    'PageController',
+    'VideoPlayerController',
+    'CameraController',
+    'ChangeNotifier',
+    'ValueNotifier',
+  ];
+
+  // Pattern-based suffixes that commonly indicate disposable resources
+  static const _disposableSuffixes = [
+    'Controller',
+    'Disposable',
+    'Subscription',
+  ];
+
+  // Methods that require corresponding cleanup
+  static const _methodPairsRequiringCleanup = {
+    'subscribe': ['unsubscribe', 'cancel'],
+    'addListener': ['removeListener'],
+    'listen': ['cancel', 'pause'],
+  };
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D002Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D002Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D002DisposeResourcesAnalyzer analyzer;
+
+  // Track disposable resources per class
+  final Map<String, List<_DisposableResource>> _disposableResourcesByClass = {};
+  // Track resources created by method calls (subscribe, addListener, etc.)
+  final Map<String, List<_DisposableResource>> _methodBasedResourcesByClass = {};
+  String? _currentClassName;
+
+  _D002Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    final className = node.name.lexeme;
+    _methodBasedResourcesByClass[className] = [];
+    _currentClassName = className;
+    _disposableResourcesByClass[className] = [];
+
+    // First: collect external resources from constructor parameters
+    final externalResources = <String>{};
+    for (final member in node.members) {
+      if (member is ConstructorDeclaration) {
+        for (final param in member.parameters.parameters) {
+          if (param is FieldFormalParameter) {
+            // this.controller pattern - external resource
+            externalResources.add(param.name.lexeme);
+          } else if (param is SimpleFormalParameter) {
+            // Check if it's assigned to a field in initializers
+            final paramName = param.name?.lexeme;
+            if (paramName != null) {
+              // Check initializer list for field assignments
+              if (member.initializers.any((init) {
+                if (init is ConstructorFieldInitializer) {
+                  return init.expression.toSource().contains(paramName);
+                }
+                return false;
+              })) {
+                externalResources.add(paramName);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Second: collect all disposable fields (only owned ones)
+    for (final member in node.members) {
+      if (member is FieldDeclaration) {
+        _visitFieldForDisposableResources(member, externalResources);
+      }
+    }
+
+    // Second pass: check if dispose method exists and handles all resources
+    MethodDeclaration? disposeMethod;
+    for (final member in node.members) {
+      if (member is MethodDeclaration && member.name.lexeme == 'dispose') {
+        disposeMethod = member;
+        break;
+      }
+    }
+
+    final disposableResources = _disposableResourcesByClass[className] ?? [];
+    final methodBasedResources = _methodBasedResourcesByClass[className] ?? [];
+    final allResources = [...disposableResources, ...methodBasedResources];
+    
+    if (allResources.isNotEmpty) {
+      if (disposeMethod == null) {
+        // No dispose method found but there are disposable resources
+        violations.add(analyzer.createViolation(
+          filePath: filePath,
+          line: analyzer.getLine(lineInfo, node.name.offset),
+          column: analyzer.getColumn(lineInfo, node.name.offset),
+          message:
+              'Class "$className" has ${allResources.length} owned disposable resource(s) but no dispose() method. '
+              'Resources: ${allResources.map((r) => r.name).join(", ")}',
+        ));
+      } else {
+        // Check if all resources are disposed
+        _checkDisposeMethodCompleteness(
+          disposeMethod,
+          allResources,
+          className,
+        );
+      }
+    }
+
+    super.visitClassDeclaration(node);
+    _currentClassName = null;
+  }
+
+  void _visitFieldForDisposableResources(
+    FieldDeclaration node,
+    Set<String> externalResources,
+  ) {
+    final type = node.fields.type?.toSource() ?? '';
+    
+    for (final variable in node.fields.variables) {
+      final variableName = variable.name.lexeme;
+      
+      // Skip external resources (from constructor parameters)
+      if (externalResources.contains(variableName)) {
+        continue;
+      }
+
+      // Skip if no initializer (might be late-initialized or constructor-assigned external resource)
+      if (variable.initializer == null && node.fields.isLate) {
+        continue;
+      }
+
+      // Determine the type to check
+      String typeToCheck = type;
+      if (typeToCheck.isEmpty && variable.initializer != null) {
+        // No explicit type annotation, infer from initializer
+        // e.g., final controller = TextEditingController()
+        final initializerStr = variable.initializer!.toSource();
+        // Extract constructor name (everything before the first '(')
+        final match = RegExp(r'(\w+)\s*\(').firstMatch(initializerStr);
+        if (match != null) {
+          typeToCheck = match.group(1) ?? '';
+        }
+      }
+      
+      // Check if the type requires disposal
+      if (_isDisposableType(typeToCheck)) {
+        // Only track if it has an initializer (owned resource)
+        if (variable.initializer != null) {
+          _disposableResourcesByClass[_currentClassName]?.add(
+            _DisposableResource(
+              name: variableName,
+              type: typeToCheck,
+              line: analyzer.getLine(lineInfo, variable.name.offset),
+              column: analyzer.getColumn(lineInfo, variable.name.offset),
+              isOwned: true,
+            ),
+          );
+        }
+      }
+      
+      // Check if the initialization calls methods that require cleanup
+      if (variable.initializer != null) {
+        _checkMethodBasedInitialization(variable);
+      }
+    }
+  }
+
+  void _checkMethodBasedInitialization(VariableDeclaration variable) {
+    final initializer = variable.initializer;
+    if (initializer == null) return;
+    
+    final initializerSource = initializer.toSource();
+    final variableName = variable.name.lexeme;
+    
+    // Check if initialization calls methods requiring cleanup
+    for (final entry in D002DisposeResourcesAnalyzer._methodPairsRequiringCleanup.entries) {
+      final setupMethod = entry.key;
+      
+      if (initializerSource.contains('.$setupMethod(')) {
+        _methodBasedResourcesByClass[_currentClassName]?.add(
+          _DisposableResource(
+            name: variableName,
+            type: 'Method-based ($setupMethod)',
+            line: analyzer.getLine(lineInfo, variable.name.offset),
+            column: analyzer.getColumn(lineInfo, variable.name.offset),
+            requiresMethodCleanup: setupMethod,
+            isOwned: true,
+          ),
+        );
+        break;
+      }
+    }
+  }
+
+  bool _isDisposableType(String type) {
+    // Remove generic parameters and null-safety markers
+    final cleanType = type.replaceAll(RegExp(r'[<>?].*'), '').trim();
+    
+    // Check exact type matches (known Flutter/Dart types)
+    final hasExactMatch = D002DisposeResourcesAnalyzer._disposableTypes.any(
+      (disposableType) => cleanType.contains(disposableType),
+    );
+    
+    if (hasExactMatch) {
+      return true;
+    }
+    
+    // Check pattern-based suffixes for custom disposable types
+    // e.g., CustomController, AppStateDisposable, UserNotifier, etc.
+    final hasSuffixMatch = D002DisposeResourcesAnalyzer._disposableSuffixes.any(
+      (suffix) => cleanType.endsWith(suffix),
+    );
+    
+    return hasSuffixMatch;
+  }
+
+  void _checkDisposeMethodCompleteness(
+    MethodDeclaration disposeMethod,
+    List<_DisposableResource> resources,
+    String className,
+  ) {
+    final disposeBody = disposeMethod.body.toSource();
+    final undisposedResources = <_DisposableResource>[];
+
+    for (final resource in resources) {
+      // Check if resource is disposed or cancelled
+      final isDisposed = _isResourceDisposed(disposeBody, resource.name);
+      
+      if (!isDisposed) {
+        undisposedResources.add(resource);
+      }
+    }
+
+    // Report violations for undisposed resources
+    for (final resource in undisposedResources) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: resource.line,
+        column: resource.column,
+        message:
+            'Resource "${resource.name}" of type "${resource.type}" is not disposed in dispose() method. '
+            'Add "${resource.name}.dispose()" or "${resource.name}.cancel()" in the dispose() method.',
+      ));
+    }
+  }
+
+  bool _isResourceDisposed(String disposeBody, String resourceName) {
+    // Common disposal patterns
+    final disposalPatterns = [
+      '$resourceName.dispose()',
+      '$resourceName?.dispose()',
+      '$resourceName.cancel()',
+      '$resourceName?.cancel()',
+      '$resourceName.close()',
+      '$resourceName?.close()',
+      '$resourceName.unsubscribe()',
+      '$resourceName?.unsubscribe()',
+      '$resourceName.removeListener(',
+      '$resourceName?.removeListener(',
+      // Check for null assignment (not ideal but acceptable)
+      '$resourceName = null',
+    ];
+
+    return disposalPatterns.any((pattern) => disposeBody.contains(pattern));
+  }
+}
+
+class _DisposableResource {
+  final String name;
+  final String type;
+  final int line;
+  final int column;
+  final String? requiresMethodCleanup; // e.g., 'subscribe', 'addListener'
+  final bool isOwned; // true if created locally, false if external
+
+  _DisposableResource({
+    required this.name,
+    required this.type,
+    required this.line,
+    required this.column,
+    this.requiresMethodCleanup,
+    this.isOwned = true,
+  });
+}

package/dart_analyzer/lib/rules/dart/D003_prefer_widgets_over_methods.dart

@@ -0,0 +1,273 @@
+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';
+
+/// D003: Prefer Widgets Over Methods Returning Widgets
+/// Recommends extracting methods that return widgets into separate widget classes
+/// for better performance, reusability, and maintainability
+class D003PreferWidgetsOverMethodsAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D003';
+
+  // Widget types to check for in return types
+  // Includes base types and common Flutter widgets
+  static const _widgetTypes = [
+    'Widget',
+    'StatelessWidget',
+    'StatefulWidget',
+    'PreferredSizeWidget',
+    'InheritedWidget',
+    'Container',
+    'Text',
+    'Column',
+    'Row',
+    'Stack',
+    'Scaffold',
+    'AppBar',
+    'ListView',
+    'GridView',
+    'Card',
+    'Padding',
+    'Center',
+    'SizedBox',
+    'Expanded',
+    'Flexible',
+    'CustomPaint',
+    'CustomScrollView',
+    'Align',
+    'AspectRatio',
+    'Baseline',
+    'ConstrainedBox',
+    'FittedBox',
+    'FractionallySizedBox',
+    'LimitedBox',
+    'Offstage',
+    'OverflowBox',
+    'SizedOverflowBox',
+    'Transform',
+    'Wrap',
+  ];
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _D003Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _D003Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final D003PreferWidgetsOverMethodsAnalyzer analyzer;
+
+  String? _currentClassName;
+  bool _insideWidgetClass = false;
+
+  _D003Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    final previousClassName = _currentClassName;
+    final previousInsideWidgetClass = _insideWidgetClass;
+
+    _currentClassName = node.name.lexeme;
+
+    // Check if this class extends a Widget
+    final extendsClause = node.extendsClause;
+    if (extendsClause != null) {
+      final superclass = extendsClause.superclass.name2.lexeme;
+      _insideWidgetClass = superclass == 'StatelessWidget' ||
+          superclass == 'StatefulWidget' ||
+          superclass.contains('Widget');
+    }
+
+    super.visitClassDeclaration(node);
+
+    _currentClassName = previousClassName;
+    _insideWidgetClass = previousInsideWidgetClass;
+  }
+
+  @override
+  void visitMethodDeclaration(MethodDeclaration node) {
+    // Only check methods inside widget classes
+    if (!_insideWidgetClass) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    // Skip the build method itself
+    final methodName = node.name.lexeme;
+    if (methodName == 'build') {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    // Skip lifecycle methods
+    if (_isLifecycleMethod(methodName)) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    // Check if method returns a Widget type
+    final returnType = node.returnType?.toSource();
+    if (returnType == null) {
+      super.visitMethodDeclaration(node);
+      return;
+    }
+
+    if (_isWidgetType(returnType)) {
+      // This is a method returning a widget - flag it
+      final isPrivate = methodName.startsWith('_');
+      final suggestion = isPrivate
+          ? 'Extract "$methodName" into a private StatelessWidget class'
+          : 'Extract "$methodName" into a StatelessWidget class';
+
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, node.name.offset),
+        column: analyzer.getColumn(lineInfo, node.name.offset),
+        message:
+            'Method "$methodName" returns a widget. $suggestion for better performance and maintainability. '
+            'Widget rebuilds will be optimized, and the code will be more reusable.',
+      ));
+    }
+
+    super.visitMethodDeclaration(node);
+  }
+
+  @override
+  void visitNamedExpression(NamedExpression node) {
+    // Check for method calls in child: or children: parameters
+    final paramName = node.name.label.name;
+    
+    if (paramName == 'child' || paramName == 'children') {
+      // Check if the value is a method invocation
+      final expression = node.expression;
+      
+      if (expression is MethodInvocation) {
+        final methodName = expression.methodName.name;
+        
+        // Flag methods that look like they build widgets
+        // Common patterns: _build*, build*, _create*, create*, _get*Widget
+        if (_looksLikeWidgetBuilderMethod(methodName)) {
+          violations.add(analyzer.createViolation(
+            filePath: filePath,
+            line: analyzer.getLine(lineInfo, expression.methodName.offset),
+            column: analyzer.getColumn(lineInfo, expression.methodName.offset),
+            message:
+                'Method call "$methodName()" in $paramName: parameter. '
+                'Extract this into a proper widget class for better performance. '
+                'Widget methods called in child/children parameters prevent optimization.',
+          ));
+        }
+      } else if (expression is ListLiteral) {
+        // Check for method calls inside children: list
+        for (final element in expression.elements) {
+          if (element is MethodInvocation) {
+            final methodName = element.methodName.name;
+            if (_looksLikeWidgetBuilderMethod(methodName)) {
+              violations.add(analyzer.createViolation(
+                filePath: filePath,
+                line: analyzer.getLine(lineInfo, element.methodName.offset),
+                column: analyzer.getColumn(lineInfo, element.methodName.offset),
+                message:
+                    'Method call "$methodName()" in children: list. '
+                    'Extract this into a proper widget class for better performance.',
+              ));
+            }
+          }
+        }
+      }
+    }
+
+    super.visitNamedExpression(node);
+  }
+
+  bool _looksLikeWidgetBuilderMethod(String methodName) {
+    // Check if method name follows common widget builder patterns
+    return methodName.startsWith('_build') ||
+           methodName.startsWith('build') ||
+           methodName.startsWith('_create') ||
+           methodName.startsWith('create') ||
+           methodName.startsWith('_get') && methodName.contains('Widget') ||
+           methodName.startsWith('get') && methodName.contains('Widget');
+  }
+
+  bool _isWidgetType(String type) {
+    // Remove generics and null-safety markers
+    final cleanType = type.replaceAll(RegExp(r'[<>?].*'), '').trim();
+
+    // Strategy 1: Check if it's a known widget type
+    final isKnownWidget = D003PreferWidgetsOverMethodsAnalyzer._widgetTypes
+        .any((widgetType) => cleanType == widgetType || cleanType.endsWith(widgetType));
+    
+    if (isKnownWidget) {
+      return true;
+    }
+
+    // Strategy 2: Check if it ends with 'Widget' (catches custom widgets)
+    // e.g., CustomWidget, UserProfileWidget, MyAppWidget
+    if (cleanType.endsWith('Widget')) {
+      return true;
+    }
+
+    // Strategy 3: Check if it ends with common widget suffixes
+    // e.g., CustomPainter, CustomClipper, CustomCard, CustomButton
+    const customWidgetSuffixes = [
+      'Painter', // CustomPainter
+      'Clipper', // CustomClipper  
+      'Card',    // CustomCard
+      'Button',  // CustomButton
+      'Dialog',  // CustomDialog
+      'Sheet',   // CustomSheet
+      'Bar',     // CustomBar, TabBar
+      'View',    // CustomView, GridView
+      'List',    // CustomList
+      'Item',    // ListItem, GridItem
+      'Tile',    // ListTile, CustomTile
+    ];
+
+    return customWidgetSuffixes.any((suffix) => cleanType.endsWith(suffix));
+  }
+
+  bool _isLifecycleMethod(String methodName) {
+    // Skip Flutter lifecycle methods
+    const lifecycleMethods = [
+      'initState',
+      'dispose',
+      'didChangeDependencies',
+      'didUpdateWidget',
+      'reassemble',
+      'deactivate',
+      'setState',
+      'createState',
+    ];
+
+    return lifecycleMethods.contains(methodName);
+  }
+}