[lint] Add lint for using null-aware elements

The lint suggests rewriting explicit null-checks, such as:

* [if (x != null) x]
* {if (x case var key?) key: "value"}

The suggested rewrite is to use the null-aware marker '?':

* [?x]
* {?x: "value"}

Change-Id: If37d096755fee14b3d9dee0f730d3302176ad0f4
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/411685
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Chloe Stefantsova <[email protected]>

Author: chloestefantsova

pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml

@@ -2512,6 +2512,8 @@ LintCode.use_late_for_private_fields_and_variables:
   status: needsFix
 LintCode.use_named_constants:
   status: hasFix
+LintCode.use_null_aware_elements:
+  status: needsFix
 LintCode.use_raw_strings:
   status: hasFix
 LintCode.use_rethrow_when_possible:

pkg/analyzer/test/verify_diagnostics_test.dart

@@ -503,8 +503,8 @@ class _SnippetTest extends PubPackageResolutionTest {
   void _createAnalysisOptionsFile() {
     var lintCode = snippet.lintCode;
     if (lintCode != null) {
-      writeTestPackageAnalysisOptionsFile(
-          analysisOptionsContent(rules: [lintCode]));
+      writeTestPackageAnalysisOptionsFile(analysisOptionsContent(
+          rules: [lintCode], experiments: snippet.experiments));
     }
   }
 

pkg/linter/CHANGELOG.md

@@ -1,5 +1,6 @@
 # 3.8.0-wip
 
+- new lint: `use_null_aware_elements`
 - new _(experimental)_ lint: `unnecessary_ignore`
 
 # 3.7.0

pkg/linter/example/all.yaml

@@ -222,6 +222,7 @@ linter:
     - use_key_in_widget_constructors
     - use_late_for_private_fields_and_variables
     - use_named_constants
+    - use_null_aware_elements
     - use_raw_strings
     - use_rethrow_when_possible
     - use_setters_to_change_properties

pkg/linter/lib/src/lint_codes.g.dart

@@ -1934,6 +1934,12 @@ class LinterLintCode extends LintCode {
     hasPublishedDocs: true,
   );
 
+  static const LintCode use_null_aware_elements = LinterLintCode(
+    LintNames.use_null_aware_elements,
+    "Use the null-aware marker '?' rather than a null check via an 'if'.",
+    correctionMessage: "Try using '?'.",
+  );
+
   static const LintCode use_raw_strings = LinterLintCode(
     LintNames.use_raw_strings,
     "Use a raw string to avoid using escapes.",

pkg/linter/lib/src/lint_names.g.dart

@@ -585,6 +585,8 @@ abstract final class LintNames {
 
   static const String use_named_constants = 'use_named_constants';
 
+  static const String use_null_aware_elements = 'use_null_aware_elements';
+
   static const String use_raw_strings = 'use_raw_strings';
 
   static const String use_rethrow_when_possible = 'use_rethrow_when_possible';

pkg/linter/lib/src/rules.dart

@@ -242,6 +242,7 @@ import 'rules/use_is_even_rather_than_modulo.dart';
 import 'rules/use_key_in_widget_constructors.dart';
 import 'rules/use_late_for_private_fields_and_variables.dart';
 import 'rules/use_named_constants.dart';
+import 'rules/use_null_aware_elements.dart';
 import 'rules/use_raw_strings.dart';
 import 'rules/use_rethrow_when_possible.dart';
 import 'rules/use_setters_to_change_properties.dart';
@@ -493,6 +494,7 @@ void registerLintRules() {
     ..registerLintRule(UseKeyInWidgetConstructors())
     ..registerLintRule(UseLateForPrivateFieldsAndVariables())
     ..registerLintRule(UseNamedConstants())
+    ..registerLintRule(UseNullAwareElements())
     ..registerLintRule(UseRawStrings())
     ..registerLintRule(UseRethrowWhenPossible())
     ..registerLintRule(UseSettersToChangeProperties())

pkg/linter/lib/src/rules/use_null_aware_elements.dart

@@ -0,0 +1,91 @@
+// Copyright (c) 2025, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/element2.dart';
+// ignore: implementation_imports
+import 'package:analyzer/src/dart/element/element.dart';
+
+import '../analyzer.dart';
+import '../extensions.dart';
+
+const _desc =
+    r'If-elements testing for null can be replaced with null-aware elements.';
+
+class UseNullAwareElements extends LintRule {
+  UseNullAwareElements()
+    : super(name: LintNames.use_null_aware_elements, description: _desc);
+
+  @override
+  LintCode get lintCode => LinterLintCode.use_null_aware_elements;
+
+  @override
+  void registerNodeProcessors(
+    NodeLintRegistry registry,
+    LinterContext context,
+  ) {
+    if (!context.isEnabled(Feature.null_aware_elements)) return;
+    var visitor = _Visitor(this);
+    registry.addIfElement(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor<void> {
+  final LintRule rule;
+
+  _Visitor(this.rule);
+
+  @override
+  void visitIfElement(IfElement node) {
+    if (node case IfElement(:var thenElement, elseKeyword: null)) {
+      Element2? nullCheckTarget;
+      if (node.expression case BinaryExpression(
+        :var operator,
+        :var leftOperand,
+        :var rightOperand,
+      ) when operator.isOperator && operator.lexeme == '!=') {
+        // Case of non-pattern null checks of the form `if (x != null) x`.
+        if (leftOperand is NullLiteral) {
+          // Cases of the form `if (null != x) x`.
+          nullCheckTarget = rightOperand.canonicalElement;
+        } else if (rightOperand is NullLiteral) {
+          // Cases of the form `if (x != null) x`.
+          nullCheckTarget = leftOperand.canonicalElement;
+        }
+      } else if (node.caseClause?.guardedPattern.pattern case NullCheckPattern(
+        pattern: DeclaredVariablePattern(:var declaredElement2),
+      )) {
+        // Case of pattern null checks of the form `if (x case var y?) y`.
+        nullCheckTarget = declaredElement2;
+      }
+
+      if (nullCheckTarget is PromotableElementImpl2) {
+        if (thenElement is SimpleIdentifier &&
+            nullCheckTarget == thenElement.canonicalElement) {
+          // List and set elements, such as the following:
+          //
+          //     [if (x != null) x]
+          //     {if (x != null) x}
+          rule.reportLintForToken(node.ifKeyword);
+        } else if (thenElement case MapLiteralEntry(:var key, :var value)) {
+          if (key is SimpleIdentifier &&
+              nullCheckTarget == key.canonicalElement) {
+            // Map keys, such as the following:
+            //
+            //     {if (x != null) x: value}
+            rule.reportLintForToken(node.ifKeyword);
+          } else if (value is SimpleIdentifier &&
+              nullCheckTarget == value.canonicalElement) {
+            // Map keys, such as the following:
+            //
+            //     {if (x != null) key: x}
+            rule.reportLintForToken(node.ifKeyword);
+          }
+        }
+      }
+    }
+  }
+}

pkg/linter/messages.yaml

@@ -14220,6 +14220,50 @@ LintCode:
       ```dart
       Duration.zero;
       ```
+  use_null_aware_elements:
+    problemMessage: "Use the null-aware marker '?' rather than a null check via an 'if'."
+    correctionMessage: "Try using '?'."
+    state:
+      stable: "3.8"
+    categories: [brevity, style]
+    hasPublishedDocs: false
+    documentation: |-
+      #### Description
+
+      The analyzer produces this diagnostic when a null check is used instead
+      of a null-aware marker inside of a collection literal.
+
+      #### Example
+
+      The following code produces this diagnostic because a null check is used
+      to decide whether `x` should be inserted into the list, while the
+      null-aware marker '?' would be less brittle and less verbose.
+
+      ```dart
+      %experiments=null-aware-elements
+      f(int? x) => [[!if!] (x != null) x];
+      ```
+
+      #### Common fixes
+
+      Replace the null-check with the null-aware marker '?':
+
+      ```dart
+      %experiments=null-aware-elements
+      f(int? x) => [?x];
+      ```
+    deprecatedDetails: |-
+      Where possible, use null-aware elements in collection literals.
+
+      **BAD:**
+      ```dart
+      f(String? key) => {if (key != null) key: "value"};
+      ```
+
+      **GOOD:**
+      ```dart
+      f(String? key) => {?key: "value"};
+      ```
   use_raw_strings:
     problemMessage: "Use a raw string to avoid using escapes."
     correctionMessage: "Try making the string a raw string and removing the escapes."

pkg/linter/test/rules/all.dart

@@ -312,6 +312,7 @@ import 'use_key_in_widget_constructors_test.dart'
 import 'use_late_for_private_fields_and_variables_test.dart'
     as use_late_for_private_fields_and_variables;
 import 'use_named_constants_test.dart' as use_named_constants;
+import 'use_null_aware_elements_test.dart' as use_null_aware_elements;
 import 'use_raw_strings_test.dart' as use_raw_strings;
 import 'use_rethrow_when_possible_test.dart' as use_rethrow_when_possible;
 import 'use_setters_to_change_properties_test.dart'
@@ -552,6 +553,7 @@ void main() {
   use_key_in_widget_constructors.main();
   use_late_for_private_fields_and_variables.main();
   use_named_constants.main();
+  use_null_aware_elements.main();
   use_raw_strings.main();
   use_rethrow_when_possible.main();
   use_setters_to_change_properties.main();