Merge remote-tracking branch 'origin/main' into unnecessary_parenthesis_ternary

Author: oprypin

CHANGELOG.md

@@ -1,8 +1,18 @@
+# 1.32.0
+
+- update `avoid_types_as_parameter_names` to handle type variables
+- update `avoid_positional_boolean_parameters` to handle typedefs
+- improve `unnecessary_parenthesis` support for property accesses and method invocations
+- update `avoid_redundant_argument_values` to check parameters of redirecting constructors
+- performance improvements for `prefer_const_literals_to_create_immutables`
+- update `use_build_context_synchronously` to check context properties
+- fix false positive for `avoid_private_typedef_functions` with generalized type aliases
+
 # 1.31.0
 
-- updated `prefer_equal_for_default_values` to not report for SDKs `>=2.19`,
+- update `prefer_equal_for_default_values` to not report for SDKs `>=2.19`,
   where this lint is now an analyzer diagnostic.
-- updated `unrelated_type_equality_checks` to support updated `package:fixnum`
+- update `unrelated_type_equality_checks` to support updated `package:fixnum`
   structure.
 
 # 1.30.0

doc/releasing.md

@@ -6,6 +6,7 @@ Before releasing there are a few boxes to tick off.
 
 * [ ] Is there a [milestone plan](https://github.com/dart-lang/linter/issues?q=is%3Aopen+is%3Aissue+label%3Amilestone-plan) for the release? If so, has it been updated?
 * [ ] Is the changelog up to date? (Look at commit history to verify.)
+  * [ ] Chronological order is fine.
 * [ ] Does the `AUTHORS` file need updating?
 * [ ] Spot check new lint rules for [naming consistency](https://github.com/dart-lang/linter/blob/main/doc/writing-lints.md).  Rename as needed.
 

example/all.yaml

@@ -123,6 +123,7 @@ linter:
     - prefer_constructors_over_static_methods
     - prefer_contains
     - prefer_double_quotes
+    - prefer_equal_for_default_values
     - prefer_expression_function_bodies
     - prefer_final_fields
     - prefer_final_in_for_each

lib/src/rules/avoid_init_to_null.dart

@@ -16,42 +16,44 @@ const _desc = r"Don't explicitly initialize variables to null.";
 const _details = r'''
 From [Effective Dart](https://dart.dev/guides/language/effective-dart/usage#dont-explicitly-initialize-variables-to-null):
 
-**DON'T** explicitly initialize variables to null.
+**DON'T** explicitly initialize variables to `null`.
 
-In Dart, a variable or field that is not explicitly initialized automatically
-gets initialized to null.  This is reliably specified by the language.  There's
-no concept of "uninitialized memory" in Dart.  Adding `= null` is redundant and
-unneeded.
+If a variable has a non-nullable type or is `final`, 
+Dart reports a compile error if you try to use it
+before it has been definitely initialized. 
+If the variable is nullable and not `const` or `final`, 
+then it is implicitly initialized to `null` for you. 
+There's no concept of "uninitialized memory" in Dart 
+and no need to explicitly initialize a variable to `null` to be "safe".
+Adding `= null` is redundant and unneeded.
 
 **BAD:**
 ```dart
-int _nextId = null;
+Item? bestDeal(List<Item> cart) {
+  Item? bestItem = null;
 
-class LazyId {
-  int _id = null;
-
-  int get id {
-    if (_nextId == null) _nextId = 0;
-    if (_id == null) _id = _nextId++;
-
-    return _id;
+  for (final item in cart) {
+    if (bestItem == null || item.price < bestItem.price) {
+      bestItem = item;
+    }
   }
+
+  return bestItem;
 }
 ```
 
 **GOOD:**
 ```dart
-int _nextId;
+Item? bestDeal(List<Item> cart) {
+  Item? bestItem;
 
-class LazyId {
-  int _id;
-
-  int get id {
-    if (_nextId == null) _nextId = 0;
-    if (_id == null) _id = _nextId++;
-
-    return _id;
+  for (final item in cart) {
+    if (bestItem == null || item.price < bestItem.price) {
+      bestItem = item;
+    }
   }
+
+  return bestItem;
 }
 ```
 

lib/src/rules/avoid_null_checks_in_equality_operators.dart

@@ -17,27 +17,28 @@ const _desc = r"Don't check for null in custom == operators.";
 const _details = r'''
 **DON'T** check for null in custom == operators.
 
-As null is a special type, no class can be equivalent to it.  Thus, it is
-redundant to check whether the other instance is null. 
+As null is a special value, no instance of any class (other than `Null`) can be
+equivalent to it.  Thus, it is redundant to check whether the other instance is
+null.
 
 **BAD:**
 ```dart
 class Person {
-  final String name;
+  final String? name;
 
   @override
-  operator ==(other) =>
+  operator ==(Object? other) =>
       other != null && other is Person && name == other.name;
 }
 ```
 
 **GOOD:**
 ```dart
 class Person {
-  final String name;
+  final String? name;
 
   @override
-  operator ==(other) => other is Person && name == other.name;
+  operator ==(Object? other) => other is Person && name == other.name;
 }
 ```
 

lib/src/rules/avoid_positional_boolean_parameters.dart

@@ -60,6 +60,7 @@ class AvoidPositionalBooleanParameters extends LintRule {
     registry.addConstructorDeclaration(this, visitor);
     registry.addFunctionDeclaration(this, visitor);
     registry.addMethodDeclaration(this, visitor);
+    registry.addGenericFunctionType(this, visitor);
   }
 }
 
@@ -105,6 +106,11 @@ class _Visitor extends SimpleAstVisitor<void> {
     }
   }
 
+  @override
+  void visitGenericFunctionType(GenericFunctionType node) {
+    checkParams(node.parameters.parameters);
+  }
+
   bool _isOverridingMember(Element member) {
     var classElement = member.thisOrAncestorOfType<ClassElement>();
     if (classElement == null) return false;

lib/src/rules/avoid_types_as_parameter_names.dart

@@ -68,8 +68,6 @@ class _Visitor extends SimpleAstVisitor<void> {
 
   @override
   void visitFormalParameterList(FormalParameterList node) {
-    if (node.parent is GenericFunctionType) return;
-
     for (var parameter in node.parameters) {
       var declaredElement = parameter.declaredElement;
       var name = parameter.name;
@@ -87,7 +85,9 @@ class _Visitor extends SimpleAstVisitor<void> {
     var result = context.resolveNameInScope(name.lexeme, false, scope);
     if (result.isRequestedName) {
       var element = result.element;
-      return element is ClassElement || element is TypeAliasElement;
+      return element is ClassElement ||
+          element is TypeAliasElement ||
+          element is TypeParameterElement;
     }
     return false;
   }

lib/src/rules/cascade_invocations.dart

@@ -105,6 +105,10 @@ bool _isInvokedWithoutNullAwareOperator(Token? token) =>
 /// Rule to lint consecutive invocations of methods or getters on the same
 /// reference that could be done with the cascade operator.
 class CascadeInvocations extends LintRule {
+  static const LintCode code = LintCode(
+      'cascade_invocations', 'Unnecessary duplication of receiver.',
+      correctionMessage: 'Try using a cascade to avoid the duplication.');
+
   /// Default constructor.
   CascadeInvocations()
       : super(
@@ -113,6 +117,9 @@ class CascadeInvocations extends LintRule {
             details: _details,
             group: Group.style);
 
+  @override
+  LintCode get lintCode => code;
+
   @override
   void registerNodeProcessors(
       NodeLintRegistry registry, LinterContext context) {

lib/src/rules/cast_nullable_to_non_nullable.dart

@@ -37,6 +37,12 @@ var v = a!;
 ''';
 
 class CastNullableToNonNullable extends LintRule {
+  static const LintCode code = LintCode('cast_nullable_to_non_nullable',
+      "Don't cast a nullable value to a non-nullable type.",
+      correctionMessage:
+          "Try adding a not-null assertion ('!') to make the type "
+          'non-nullable.');
+
   CastNullableToNonNullable()
       : super(
           name: 'cast_nullable_to_non_nullable',
@@ -46,6 +52,9 @@ class CastNullableToNonNullable extends LintRule {
           group: Group.style,
         );
 
+  @override
+  LintCode get lintCode => code;
+
   @override
   void registerNodeProcessors(
       NodeLintRegistry registry, LinterContext context) {
@@ -59,10 +68,10 @@ class CastNullableToNonNullable extends LintRule {
 }
 
 class _Visitor extends SimpleAstVisitor<void> {
-  _Visitor(this.rule, this.context);
-
   final LintRule rule;
+
   final LinterContext context;
+  _Visitor(this.rule, this.context);
 
   @override
   void visitAsExpression(AsExpression node) {

lib/src/rules/conditional_uri_does_not_exist.dart

@@ -31,13 +31,22 @@ import 'file_that_does_exist.dart'
 ''';
 
 class ConditionalUriDoesNotExist extends LintRule {
+  static const LintCode code = LintCode('conditional_uri_does_not_exist',
+      "The target of a conditional import doesn't exist.",
+      correctionMessage:
+          'Try creating the imported file or changing the URI to reference an '
+          'existing file.');
+
   ConditionalUriDoesNotExist()
       : super(
             name: 'conditional_uri_does_not_exist',
             description: _desc,
             details: _details,
             group: Group.style);
 
+  @override
+  LintCode get lintCode => code;
+
   @override
   void registerNodeProcessors(
       NodeLintRegistry registry, LinterContext context) {