new lint: invalid_case_patterns

example/all.yaml

@@ -77,6 +77,7 @@ linter:
     - hash_and_equals
     - implementation_imports
     - implicit_call_tearoffs
+    - invalid_case_patterns
     - iterable_contains_unrelated_type
     - join_return_with_assignment
     - leading_newlines_in_multiline_strings

lib/src/rules.dart

@@ -83,6 +83,7 @@ import 'rules/flutter_style_todos.dart';
 import 'rules/hash_and_equals.dart';
 import 'rules/implementation_imports.dart';
 import 'rules/implicit_call_tearoffs.dart';
+import 'rules/invalid_case_patterns.dart';
 import 'rules/invariant_booleans.dart';
 import 'rules/iterable_contains_unrelated_type.dart';
 import 'rules/join_return_with_assignment.dart';
@@ -308,6 +309,7 @@ void registerLintRules({bool inTestMode = false}) {
     ..register(ImplementationImports())
     ..register(ImplicitCallTearoffs())
     ..register(InvariantBooleans())
+    ..register(InvalidCasePatterns())
     ..register(IterableContainsUnrelatedType())
     ..register(JoinReturnWithAssignment())
     ..register(LeadingNewlinesInMultilineStrings())

lib/src/rules/invalid_case_patterns.dart

@@ -0,0 +1,92 @@
+// Copyright (c) 2023, 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/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+
+import '../analyzer.dart';
+
+const _desc = r'Use case expressions that are valid in Dart 3.0.';
+
+/// todo(pq): add details or link out to a doc?
+const _details = r'''
+Some case expressions that are valid in Dart 2.19 and below will become an error
+or have changed semantics when a library is upgraded to 3.0. This lint flags
+those expressions in order to ease migration to Dart 3.0.
+''';
+
+class InvalidCasePatterns extends LintRule {
+  static const LintCode code = LintCode(
+      'invalid_case_patterns', 'Invalid case pattern.',
+      // todo(pq): can we have a doc link here?
+      correctionMessage: 'Try refactoring the expression to be valid in 3.0.');
+
+  InvalidCasePatterns()
+      : super(
+            name: 'invalid_case_patterns',
+            description: _desc,
+            details: _details,
+            group: Group.errors);
+
+  @override
+  LintCode get lintCode => code;
+
+  @override
+  void registerNodeProcessors(
+      NodeLintRegistry registry, LinterContext context) {
+    var visitor = _Visitor(this);
+    registry.addSwitchCase(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor {
+  final LintRule rule;
+
+  _Visitor(this.rule);
+
+  @override
+  visitSwitchCase(SwitchCase node) {
+    var expression = node.expression;
+    if (expression is SetOrMapLiteral) {
+      rule.reportLint(expression);
+    } else if (expression is ListLiteral) {
+      rule.reportLint(expression);
+    } else if (expression is ParenthesizedExpression) {
+      rule.reportLint(expression);
+    } else if (expression is MethodInvocation) {
+      if (expression.methodName.isDartCoreIdentifier(named: 'identical')) {
+        rule.reportLint(expression);
+      }
+    } else if (expression is PrefixExpression) {
+      rule.reportLint(expression);
+    } else if (expression is BinaryExpression) {
+      rule.reportLint(expression);
+    } else if (expression is ConditionalExpression) {
+      rule.reportLint(expression);
+    } else if (expression is PropertyAccess) {
+      if (expression.propertyName.isDartCoreIdentifier(named: 'length')) {
+        rule.reportLint(expression);
+      }
+    } else if (expression is IsExpression) {
+      rule.reportLint(expression);
+    } else if (expression is InstanceCreationExpression) {
+      if (expression.isConst) {
+        rule.reportLint(expression);
+      }
+    } else if (expression is SimpleIdentifier) {
+      var token = expression.token;
+      if (token is StringToken && token.lexeme == '_') {
+        rule.reportLint(expression);
+      }
+    }
+  }
+}
+
+extension on SimpleIdentifier {
+  bool isDartCoreIdentifier({required String named}) {
+    if (name != named) return false;
+    var library = staticElement?.library;
+    return library != null && library.isDartCore;
+  }
+}

test/rules/all.dart

@@ -41,6 +41,7 @@ import 'discarded_futures_test.dart' as discarded_futures;
 import 'file_names_test.dart' as file_names;
 import 'flutter_style_todos_test.dart' as flutter_style_todos;
 import 'hash_and_equals_test.dart' as hash_and_equals;
+import 'invalid_case_patterns_test.dart' as invalid_case_patterns;
 import 'library_annotations_test.dart' as library_annotations;
 import 'library_names_test.dart' as library_names;
 import 'library_private_types_in_public_api_test.dart'
@@ -126,6 +127,7 @@ void main() {
   file_names.main();
   flutter_style_todos.main();
   hash_and_equals.main();
+  invalid_case_patterns.main();
   library_annotations.main();
   library_names.main();
   library_private_types_in_public_api.main();

test/rules/invalid_case_patterns_test.dart

@@ -0,0 +1,182 @@
+// Copyright (c) 2023, 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:test_reflective_loader/test_reflective_loader.dart';
+
+import '../rule_test_support.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(InvalidCasePatternsTest);
+  });
+}
+
+@reflectiveTest
+class InvalidCasePatternsTest extends LintRuleTest {
+  @override
+  String get lintRule => 'invalid_case_patterns';
+
+  test_binaryExpression() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case 1 + 2:
+  }
+}
+''', [
+      lint(43, 5),
+    ]);
+  }
+
+  test_binaryExpression_logic() async {
+    await assertDiagnostics(r'''
+f(bool b) {
+  switch (b) {
+    case true && false:
+  }
+}
+''', [
+      lint(36, 13),
+    ]);
+  }
+
+  test_conditionalExpression() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case true ? 1 : 2: 
+  }
+}
+''', [
+      lint(43, 12),
+      error(HintCode.DEAD_CODE, 54, 1),
+    ]);
+  }
+
+  test_constConstructorCall() async {
+    await assertDiagnostics(r'''
+class C {
+  const C();
+}
+
+f(C c) {
+  switch (c) {
+    case C():
+  }
+}
+''', [
+      lint(59, 3),
+    ]);
+  }
+
+  test_identicalCall() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case identical(1, 2):
+  }
+}
+''', [
+      lint(43, 15),
+    ]);
+  }
+
+  test_isExpression() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+      case 1 is int:
+  }
+}
+''', [
+      error(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, 45, 8),
+      lint(45, 8),
+    ]);
+  }
+
+  test_lengthCall() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case ''.length: 
+  }
+}
+''', [
+      lint(43, 9),
+    ]);
+  }
+
+  test_listLiteral() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case [1, 2]:
+  }
+}
+''', [
+      lint(43, 6),
+    ]);
+  }
+
+  test_mapLiteral() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+   case {'k': 'v'}:
+  }
+}
+''', [
+      lint(42, 10),
+    ]);
+  }
+
+  test_parenthesizedExpression() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case (1):
+  }
+}
+''', [
+      lint(43, 3),
+    ]);
+  }
+
+  test_prefixedExpression() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case -1:
+  }
+}
+''', [
+      lint(43, 2),
+    ]);
+  }
+
+  test_setLiteral() async {
+    await assertDiagnostics(r'''
+void f(Object o) {
+  switch (o) {
+    case {1}:
+  }
+}
+''', [
+      lint(43, 3),
+    ]);
+  }
+
+  test_wildcard() async {
+    await assertDiagnostics(r'''
+f(int n) {
+  const _ = 3;
+  switch (n) {
+    case _:
+  }
+}
+''', [
+      lint(50, 1),
+    ]);
+  }
+}