Adjust unrelated_type_equality_checks on mixins and extension types

The lint unrelated_type_equality_checks previously considered all mixins
and extension types to be (possibly) related (even any mixin and any
extension type, not just any pair of mixins and any pair of extension
types). This would not fit the expectations for this lint, it should
certainly consider a mixin as unrelated to an extension type that isn't
a subtype of the mixin, and similarly for any pair of mixins that aren't
subtype related, and any pair of extension types that aren't subtype
related.

This PR changes the lint (that is, the underlying extension method
`interfaceTypesAreUnrelated`) such that these pairs are considered
unrelated.

Bug: #59423
Change-Id: I370e98eb17c60ab50f1118b6e841d7eee7291e54
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/440640
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>

Author: eernstg

pkg/analyzer/lib/src/fine/manifest_item.dart

@@ -38,7 +38,9 @@ class ClassItem extends InterfaceItem<ClassElementImpl> {
     required EncodeContext context,
     required ClassElementImpl element,
   }) {
-    return context.withTypeParameters(element.typeParameters, (typeParameters) {
+    return context.withTypeParameters(element.typeParameters, (
+      typeParameters,
+    ) {
       return ClassItem(
         id: id,
         metadata: ManifestMetadata.encode(context, element.metadata),
@@ -101,7 +103,9 @@ class EnumItem extends InterfaceItem<EnumElementImpl> {
     required EncodeContext context,
     required EnumElementImpl element,
   }) {
-    return context.withTypeParameters(element.typeParameters, (typeParameters) {
+    return context.withTypeParameters(element.typeParameters, (
+      typeParameters,
+    ) {
       return EnumItem(
         id: id,
         metadata: ManifestMetadata.encode(context, element.metadata),
@@ -164,7 +168,9 @@ class ExtensionItem<E extends ExtensionElementImpl> extends InstanceItem<E> {
     required EncodeContext context,
     required ExtensionElementImpl element,
   }) {
-    return context.withTypeParameters(element.typeParameters, (typeParameters) {
+    return context.withTypeParameters(element.typeParameters, (
+      typeParameters,
+    ) {
       return ExtensionItem(
         id: id,
         metadata: ManifestMetadata.encode(context, element.metadata),
@@ -233,7 +239,9 @@ class ExtensionTypeItem extends InterfaceItem<ExtensionTypeElementImpl> {
     required EncodeContext context,
     required ExtensionTypeElementImpl element,
   }) {
-    return context.withTypeParameters(element.typeParameters, (typeParameters) {
+    return context.withTypeParameters(element.typeParameters, (
+      typeParameters,
+    ) {
       return ExtensionTypeItem(
         id: id,
         metadata: ManifestMetadata.encode(context, element.metadata),
@@ -1136,7 +1144,9 @@ class MixinItem extends InterfaceItem<MixinElementImpl> {
     required EncodeContext context,
     required MixinElementImpl element,
   }) {
-    return context.withTypeParameters(element.typeParameters, (typeParameters) {
+    return context.withTypeParameters(element.typeParameters, (
+      typeParameters,
+    ) {
       return MixinItem(
         id: id,
         metadata: ManifestMetadata.encode(context, element.metadata),
@@ -1391,7 +1401,9 @@ class TypeAliasItem extends TopLevelItem<TypeAliasElementImpl> {
     required EncodeContext context,
     required TypeAliasElementImpl element,
   }) {
-    return context.withTypeParameters(element.typeParameters, (typeParameters) {
+    return context.withTypeParameters(element.typeParameters, (
+      typeParameters,
+    ) {
       return TypeAliasItem(
         id: id,
         metadata: ManifestMetadata.encode(context, element.metadata),

pkg/linter/lib/src/util/dart_type_utilities.dart

@@ -154,6 +154,8 @@ bool canonicalElementsFromIdentifiersAreEqual(
 ///   * are unrelated if [leftType]'s supertype is [Object].
 ///   * are related if their supertypes are equal, e.g. `List<dynamic>` and
 ///     `Set<dynamic>`.
+///   * are unrelated if they are distinct mixins.
+///   * are unrelated if they are distinct extension types.
 /// * Two type variables are related if their bounds are related.
 /// * A record type is unrelated to any other type except a record type of
 ///   the same shape.
@@ -282,11 +284,14 @@ extension on TypeSystem {
       // Otherwise, they might be related.
       return false;
     } else {
-      var sameSupertypes = leftElement.supertype == rightElement.supertype;
+      var leftSuper = leftElement.supertype;
+      var sameSupertypes = leftSuper == rightElement.supertype;
 
-      // Unrelated Enums have the same supertype, but they are not the same element, so
-      // they are unrelated.
-      if (sameSupertypes && leftElement is EnumElement) {
+      // Unrelated Enums have the same supertype, but they are not the same
+      // element, so they are unrelated. Mixins always have supertype null,
+      // and so do extension types, and they are both considered unrelated
+      // when their elements are not equal.
+      if (sameSupertypes && (leftElement is EnumElement || leftSuper == null)) {
         return true;
       }
 

pkg/linter/test/rules/unrelated_type_equality_checks_test.dart

@@ -37,6 +37,31 @@ void f(dynamic x) {
 ''');
   }
 
+  test_extension_types() async {
+    await assertDiagnostics(
+      r'''
+void m(A a, B b) {
+  if (a == b) {}
+}
+extension type A(String value) {}
+extension type B(String value) {}
+''',
+      [lint(27, 2)],
+    );
+  }
+
+  test_extension_types_ok() async {
+    await assertNoDiagnostics(r'''
+void m(A a1, A a2, B b) {
+  if (a1 == a2) {}
+  if (a1 == b) {}
+  if (b == a1) {}
+}
+extension type A(String value) {}
+extension type B(String value) implements A {}
+''');
+  }
+
   test_fixnum_int32_leftSide() async {
     await assertNoDiagnostics(r'''
 import 'package:fixnum/fixnum.dart';
@@ -119,6 +144,29 @@ class C with M {}
 ''');
   }
 
+  test_mixins() async {
+    await assertDiagnostics(
+      r'''
+void f(M1 m1, M2 m2) {
+  if (m1 == m2) {}
+}
+mixin M1 {}
+mixin M2 {}
+''',
+      [lint(32, 2)],
+    );
+  }
+
+  test_mixins_ok() async {
+    await assertNoDiagnostics(r'''
+void f(M1 m1, M2 m2) {
+  if (m1 == m2) {}
+}
+mixin M1 on M2 {}
+mixin M2 {}
+''');
+  }
+
   test_object_andArbitraryType() async {
     await assertNoDiagnostics(r'''
 void f(Object x, C y) {