@sun-asterisk/sunlint 1.3.43 → 1.3.44

package/dart_analyzer/lib/rules/common/C076_explicit_function_types.dart

@@ -0,0 +1,104 @@
+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';
+
+/// C076: Explicit Function Types
+/// Function parameters should have explicit type annotations
+class C076ExplicitFunctionTypesAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'C076';
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    final visitor = _C076Visitor(
+      filePath: filePath,
+      lineInfo: lineInfo,
+      violations: violations,
+      analyzer: this,
+    );
+
+    unit.accept(visitor);
+
+    return violations;
+  }
+}
+
+class _C076Visitor extends RecursiveAstVisitor<void> {
+  final String filePath;
+  final LineInfo lineInfo;
+  final List<Violation> violations;
+  final C076ExplicitFunctionTypesAnalyzer analyzer;
+
+  _C076Visitor({
+    required this.filePath,
+    required this.lineInfo,
+    required this.violations,
+    required this.analyzer,
+  });
+
+  @override
+  void visitFormalParameterList(FormalParameterList node) {
+    // Skip lambda/closure parameters - they're inferable from context
+    if (_isLambdaParameter(node)) {
+      super.visitFormalParameterList(node);
+      return;
+    }
+    
+    for (final param in node.parameters) {
+      _checkParameter(param);
+    }
+    super.visitFormalParameterList(node);
+  }
+
+  bool _isLambdaParameter(FormalParameterList node) {
+    // Check if this parameter list belongs to a FunctionExpression (lambda/closure)
+    final parent = node.parent;
+    return parent is FunctionExpression;
+  }
+
+  void _checkParameter(FormalParameter param) {
+    // Handle SimpleFormalParameter (regular parameters)
+    if (param is SimpleFormalParameter) {
+      if (param.type == null && param.name != null) {
+        _reportViolation(param.name!.lexeme, param.offset);
+      }
+    }
+    // Handle DefaultFormalParameter (named and optional positional parameters)
+    else if (param is DefaultFormalParameter) {
+      final innerParam = param.parameter;
+      // Check the inner parameter (could be SimpleFormalParameter or FieldFormalParameter)
+      if (innerParam is SimpleFormalParameter) {
+        if (innerParam.type == null && innerParam.name != null) {
+          _reportViolation(innerParam.name!.lexeme, innerParam.offset);
+        }
+      }
+      // FieldFormalParameter (this.field) inherits type from field, so skip
+    }
+    // FieldFormalParameter at top level (this.field) - skip, inherits type
+    // FunctionTypedFormalParameter - already has type definition
+  }
+
+  void _reportViolation(String name, int offset) {
+    // Skip underscore (unused) parameters
+    if (!name.startsWith('_')) {
+      violations.add(analyzer.createViolation(
+        filePath: filePath,
+        line: analyzer.getLine(lineInfo, offset),
+        column: analyzer.getColumn(lineInfo, offset),
+        message: 'Parameter "$name" should have an explicit type annotation',
+      ));
+    }
+  }
+
+}

package/dart_analyzer/lib/rules/dart/D001_recommended_lint_rules.dart

@@ -0,0 +1,309 @@
+import 'dart:io';
+
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/source/line_info.dart';
+import 'package:path/path.dart' as path;
+import 'package:yaml/yaml.dart';
+
+import '../../models/rule.dart';
+import '../../models/violation.dart';
+import '../base_analyzer.dart';
+
+/// D001: Recommended Lint Rules Should Be Enabled
+/// Ensures that analysis_options.yaml includes recommended lint packages
+/// (flutter_lints, very_good_analysis, or lints) and critical rules are enabled
+class D001RecommendedLintRulesAnalyzer extends BaseAnalyzer {
+  @override
+  String get ruleId => 'D001';
+
+  // Recommended lint packages that provide good defaults
+  static const _recommendedPackages = [
+    'flutter_lints',
+    'very_good_analysis',
+    'lints',
+    'pedantic',
+    'effective_dart',
+  ];
+
+  // Critical rules that should not be disabled
+  static const _criticalRules = [
+    // Error-level rules - these catch real bugs
+    'avoid_empty_else',
+    'avoid_print',
+    'avoid_returning_null_for_future',
+    'avoid_type_to_string',
+    'avoid_types_as_parameter_names',
+    'cancel_subscriptions',
+    'close_sinks',
+    'empty_statements',
+    'hash_and_equals',
+    'no_duplicate_case_values',
+    'throw_in_finally',
+    'unnecessary_statements',
+    'unrelated_type_equality_checks',
+    'valid_regexps',
+  ];
+
+  // Rules that are highly recommended but can be disabled with justification
+  // Reserved for future use when we add warnings for disabling recommended rules
+  // ignore: unused_field
+  static const _recommendedRules = [
+    'always_declare_return_types',
+    'annotate_overrides',
+    'await_only_futures',
+    'camel_case_types',
+    'curly_braces_in_flow_control_structures',
+    'empty_catches',
+    'exhaustive_cases',
+    'file_names',
+    'prefer_const_constructors',
+    'prefer_final_fields',
+    'prefer_is_empty',
+    'prefer_is_not_empty',
+  ];
+
+  // Track which projects we've already checked to avoid duplicate checks
+  static final Set<String> _checkedProjects = {};
+  
+  // Track visited files to prevent infinite loops in include chains
+  final Set<String> _visitedFiles = {};
+
+  @override
+  List<Violation> analyze({
+    required CompilationUnit unit,
+    required String filePath,
+    required Rule rule,
+    required LineInfo lineInfo,
+  }) {
+    final violations = <Violation>[];
+
+    // This rule analyzes analysis_options.yaml, not Dart files
+    // We need to find and analyze the analysis_options.yaml in the project
+    final projectRoot = _findProjectRoot(filePath);
+    if (projectRoot == null) {
+      return violations;
+    }
+
+    // Performance optimization: Skip if we've already checked this project
+    if (_checkedProjects.contains(projectRoot)) {
+      return violations;
+    }
+
+    // Mark as checked immediately
+    _checkedProjects.add(projectRoot);
+
+    final analysisOptionsPath = path.join(projectRoot, 'analysis_options.yaml');
+    final analysisOptionsFile = File(analysisOptionsPath);
+
+    if (!analysisOptionsFile.existsSync()) {
+      // No analysis_options.yaml - this is a violation
+      violations.add(createViolation(
+        filePath: filePath,
+        line: 1,
+        column: 1,
+        message:
+            'Missing analysis_options.yaml. Add one with recommended lint rules (flutter_lints or very_good_analysis)',
+      ));
+      return violations;
+    }
+
+    // Parse and analyze the YAML file
+    try {
+      final content = analysisOptionsFile.readAsStringSync();
+      final yaml = loadYaml(content);
+
+      if (yaml is! YamlMap) {
+        violations.add(createViolation(
+          filePath: analysisOptionsPath,
+          line: 1,
+          column: 1,
+          message: 'Invalid analysis_options.yaml format',
+        ));
+        return violations;
+      }
+
+      // Check for include statement (recommended packages)
+      // Follow include chains recursively
+      final hasRecommendedPackage = _checkForRecommendedPackage(
+        yaml, 
+        content, 
+        projectRoot,
+        analysisOptionsPath,
+      );
+      if (!hasRecommendedPackage) {
+        violations.add(createViolation(
+          filePath: analysisOptionsPath,
+          line: 1,
+          column: 1,
+          message:
+              'analysis_options.yaml should include a recommended lint package. '
+              'Add: include: package:flutter_lints/flutter.yaml or package:very_good_analysis/analysis_options.yaml',
+        ));
+      }
+
+      // Check for disabled critical rules
+      final disabledCriticalRules =
+          _findDisabledCriticalRules(yaml, content, analysisOptionsPath);
+      violations.addAll(disabledCriticalRules);
+    } catch (e) {
+      // YAML parsing error - skip this file
+    }
+
+    return violations;
+  }
+
+  String? _findProjectRoot(String filePath) {
+    var dir = Directory(path.dirname(filePath));
+
+    while (dir.path != dir.parent.path) {
+      final pubspec = File(path.join(dir.path, 'pubspec.yaml'));
+      if (pubspec.existsSync()) {
+        return dir.path;
+      }
+      dir = dir.parent;
+    }
+
+    return null;
+  }
+
+  bool _checkForRecommendedPackage(
+    YamlMap yaml, 
+    String content, 
+    String projectRoot,
+    String currentFilePath,
+  ) {
+    // Prevent infinite loops in circular includes
+    if (_visitedFiles.contains(currentFilePath)) {
+      return false;
+    }
+    _visitedFiles.add(currentFilePath);
+
+    // Check direct include statement
+    final include = yaml['include'];
+    if (include != null && include is String) {
+      // Check if it's a package include with recommended package
+      if (include.startsWith('package:')) {
+        for (final pkg in _recommendedPackages) {
+          if (include.contains(pkg)) {
+            return true;
+          }
+        }
+      }
+      
+      // Follow local file includes
+      if (!include.startsWith('package:')) {
+        final includedFile = _resolveIncludePath(include, projectRoot, currentFilePath);
+        if (includedFile != null && includedFile.existsSync()) {
+          try {
+            final includedContent = includedFile.readAsStringSync();
+            final includedYaml = loadYaml(includedContent);
+            
+            if (includedYaml is YamlMap) {
+              // Recursively check the included file
+              final foundInIncluded = _checkForRecommendedPackage(
+                includedYaml,
+                includedContent,
+                projectRoot,
+                includedFile.path,
+              );
+              if (foundInIncluded) {
+                return true;
+              }
+            }
+          } catch (e) {
+            // Failed to parse included file, skip it
+          }
+        }
+      }
+    }
+
+    // Also check if content has package: in include (regex fallback)
+    final includePattern = RegExp(r'include:\s*package:(\w+)');
+    final match = includePattern.firstMatch(content);
+    if (match != null) {
+      final packageName = match.group(1);
+      if (packageName != null &&
+          _recommendedPackages
+              .any((pkg) => pkg.replaceAll('_', '').contains(packageName))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+  
+  File? _resolveIncludePath(String includePath, String projectRoot, String currentFilePath) {
+    // Handle absolute paths
+    if (path.isAbsolute(includePath)) {
+      return File(includePath);
+    }
+    
+    // Handle relative paths (relative to current file's directory)
+    final currentDir = path.dirname(currentFilePath);
+    final resolvedPath = path.normalize(path.join(currentDir, includePath));
+    
+    return File(resolvedPath);
+  }
+
+  List<Violation> _findDisabledCriticalRules(
+      YamlMap yaml, String content, String filePath) {
+    final violations = <Violation>[];
+
+    final linter = yaml['linter'];
+    if (linter == null || linter is! YamlMap) {
+      return violations;
+    }
+
+    final rules = linter['rules'];
+    if (rules == null) {
+      return violations;
+    }
+
+    if (rules is YamlMap) {
+      // Rules as map: { rule_name: false }
+      for (final rule in _criticalRules) {
+        final ruleValue = rules[rule];
+        if (ruleValue == false) {
+          final lineNumber = _findLineNumber(content, rule);
+          violations.add(createViolation(
+            filePath: filePath,
+            line: lineNumber,
+            column: 1,
+            message:
+                'Critical lint rule "$rule" should not be disabled. It helps catch real bugs.',
+          ));
+        }
+      }
+    } else if (rules is YamlList) {
+      // Rules as list with negation: [ avoid_print: false ]
+      for (final item in rules) {
+        if (item is YamlMap) {
+          for (final rule in _criticalRules) {
+            if (item.containsKey(rule) && item[rule] == false) {
+              final lineNumber = _findLineNumber(content, rule);
+              violations.add(createViolation(
+                filePath: filePath,
+                line: lineNumber,
+                column: 1,
+                message:
+                    'Critical lint rule "$rule" should not be disabled. It helps catch real bugs.',
+              ));
+            }
+          }
+        }
+      }
+    }
+
+    return violations;
+  }
+
+  int _findLineNumber(String content, String searchText) {
+    final lines = content.split('\n');
+    for (var i = 0; i < lines.length; i++) {
+      if (lines[i].contains(searchText)) {
+        return i + 1;
+      }
+    }
+    return 1;
+  }
+}