+ implicit_reopen

example/all.yaml

@@ -78,6 +78,7 @@ linter:
     - hash_and_equals
     - implementation_imports
     - implicit_call_tearoffs
+    - implicit_reopen
     - invalid_case_patterns
     - iterable_contains_unrelated_type
     - join_return_with_assignment

lib/src/rules.dart

@@ -84,6 +84,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/implicit_reopen.dart';
 import 'rules/invalid_case_patterns.dart';
 import 'rules/invariant_booleans.dart';
 import 'rules/iterable_contains_unrelated_type.dart';
@@ -310,6 +311,7 @@ void registerLintRules({bool inTestMode = false}) {
     ..register(HashAndEquals())
     ..register(ImplementationImports())
     ..register(ImplicitCallTearoffs())
+    ..register(ImplicitReopen())
     ..register(InvariantBooleans())
     ..register(InvalidCasePatterns())
     ..register(IterableContainsUnrelatedType())

lib/src/rules/implicit_reopen.dart

@@ -0,0 +1,171 @@
+// 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 'package:analyzer/dart/element/element.dart';
+
+import '../analyzer.dart';
+
+const _desc = r"Don't implicitly reopen classes or mixins.";
+
+/// todo(pq): link out to (upcoming) dart.dev docs.
+/// https://github.com/dart-lang/site-www/issues/4497
+const _details = r'''
+Using the `interface`, `final`, `base`, `mixin`, and `sealed` class modifiers,
+authors can control whether classes and mixins allow being implemented,
+extended, and/or mixed in from outside of the library where they're defined.
+In some cases, it's possible for an author to inadvertantly relax these controls
+and implicitly "reopen" a class or mixin. 
+
+This lint guards against unintentionally reopening a type by requiring such
+cases to be made explicit with the 
+[`@reopen`](https://pub.dev/documentation/meta/latest/meta/reopen-constant.html)
+annotation in `package:meta`.
+
+**BAD:**
+```dart
+interface class I {}
+
+class C extends I {}
+```
+
+**GOOD:**
+```dart
+interface class I {}
+
+final class C extends I {}
+```
+
+```dart
+import 'package:meta/meta.dart';
+
+interface class I {}
+
+@reopen
+class C extends I {}
+```
+''';
+
+class ImplicitReopen extends LintRule {
+  static const LintCode code = LintCode('implicit_reopen',
+      "The {0} '{1}' reopens '{2}' because it is not marked '{3}'",
+      correctionMessage:
+          "Try marking '{1}' '{3}' or annotating it with '@reopen'");
+
+  ImplicitReopen()
+      : super(
+            name: 'implicit_reopen',
+            description: _desc,
+            details: _details,
+            state: State.experimental(),
+            group: Group.errors);
+
+  @override
+  LintCode get lintCode => code;
+
+  @override
+  void registerNodeProcessors(
+      NodeLintRegistry registry, LinterContext context) {
+    var visitor = _Visitor(this);
+    registry.addClassDeclaration(this, visitor);
+  }
+}
+
+class _Visitor extends SimpleAstVisitor {
+  final LintRule rule;
+
+  _Visitor(this.rule);
+
+  void checkElement(InterfaceElement? element, NamedCompilationUnitMember node,
+      {required String type}) {
+    if (element == null) return;
+    if (element.hasReopen) return;
+    if (element.isSealed) return;
+    if (element.isMixinClass) return;
+
+    var library = element.library;
+    var supertype = element.superElement;
+    if (supertype.library != library) return;
+
+    if (element.isBase) {
+      if (supertype.isFinal) {
+        reportLint(node,
+            target: element, other: supertype!, reason: 'final', type: type);
+        return;
+      } else if (supertype.isInterface) {
+        reportLint(node,
+            target: element,
+            other: supertype!,
+            reason: 'interface',
+            type: type);
+        return;
+      }
+    } else if (element.hasNoModifiers) {
+      if (supertype.isInterface) {
+        reportLint(node,
+            target: element,
+            other: supertype!,
+            reason: 'interface',
+            type: type);
+        return;
+      }
+    }
+  }
+
+  void reportLint(
+    NamedCompilationUnitMember member, {
+    required String type,
+    required InterfaceElement target,
+    required InterfaceElement other,
+    required String reason,
+  }) {
+    rule.reportLintForToken(member.name,
+        arguments: [type, target.name, other.name, reason]);
+  }
+
+  @override
+  void visitClassDeclaration(ClassDeclaration node) {
+    checkElement(node.declaredElement, node, type: 'class');
+  }
+}
+
+extension on InterfaceElement? {
+  bool get hasNoModifiers => !isInterface && !isBase && !isSealed && !isFinal;
+
+  bool get isBase {
+    var self = this;
+    if (self is ClassElement) return self.isBase;
+    if (self is MixinElement) return self.isBase;
+    return false;
+  }
+
+  bool get isFinal {
+    var self = this;
+    if (self is ClassElement) return self.isFinal;
+    return false;
+  }
+
+  bool get isInterface {
+    var self = this;
+    if (self is ClassElement) return self.isInterface;
+    return false;
+  }
+
+  bool get isSealed {
+    var self = this;
+    if (self is ClassElement) return self.isSealed;
+    return false;
+  }
+
+  bool get isMixinClass {
+    var self = this;
+    if (self is ClassElement) return self.isMixinClass;
+    return false;
+  }
+
+  LibraryElement? get library => this?.library;
+
+  InterfaceElement? get superElement => this?.supertype?.element;
+}

test/rules/all.dart

@@ -48,6 +48,7 @@ import 'exhaustive_cases_test.dart' as exhaustive_cases;
 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 'implicit_reopen_test.dart' as implicit_reopen;
 import 'invalid_case_patterns_test.dart' as invalid_case_patterns;
 import 'join_return_with_assignment_test.dart' as join_return_with_assignment;
 import 'library_annotations_test.dart' as library_annotations;
@@ -159,6 +160,7 @@ void main() {
   file_names.main();
   flutter_style_todos.main();
   hash_and_equals.main();
+  implicit_reopen.main();
   invalid_case_patterns.main();
   join_return_with_assignment.main();
   library_annotations.main();