Issue 45195. Report MIXIN_INHERITS_FROM_NOT_OBJECT for class aliases.

Bug: dart-lang#45195
Change-Id: I4b1e60a672b49c3c9fda92b3eac59c256eea13da
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/189300
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -3267,17 +3267,20 @@ class ErrorVerifier extends RecursiveAstVisitor<void> {
   bool _checkForMixinInheritsNotFromObject(
       TypeName mixinName, ClassElement mixinElement) {
     var mixinSupertype = mixinElement.supertype;
-    if (mixinSupertype != null) {
-      if (!mixinSupertype.isDartCoreObject ||
-          !mixinElement.isMixinApplication && mixinElement.mixins.isNotEmpty) {
-        _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT,
-            mixinName,
-            [mixinElement.name]);
-        return true;
+    if (mixinSupertype == null || mixinSupertype.isDartCoreObject) {
+      var mixins = mixinElement.mixins;
+      if (mixins.isEmpty ||
+          mixinElement.isMixinApplication && mixins.length < 2) {
+        return false;
       }
     }
-    return false;
+
+    _errorReporter.reportErrorForNode(
+      CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT,
+      mixinName,
+      [mixinElement.name],
+    );
+    return true;
   }
 
   /// Check that superclass constrains for the mixin type of [mixinName] at

pkg/analyzer/test/generated/non_error_resolver_test.dart

@@ -2340,13 +2340,15 @@ class C = Object with B;
     // B's superclass is "Object with A1<T>".  So mixin type inference succeeds
     // (since C's base class implements A1<int>), and "with B" is interpreted as
     // "with B<int>".
-    await assertNoErrorsInCode('''
+    await assertErrorsInCode('''
 class A1<T> {}
 class A2<T> {}
 class B<T> = Object with A1<T>, A2<T>;
 class Base implements A1<int> {}
 class C = Base with B;
-''');
+''', [
+      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 122, 1),
+    ]);
     var bReference = result.unit!.declaredElement!.getType('C')!.mixins[0];
     assertType(bReference.typeArguments[0], 'int');
   }

pkg/analyzer/test/src/diagnostics/mixin_inherits_from_not_object_test.dart

@@ -15,75 +15,105 @@ main() {
 
 @reflectiveTest
 class MixinInheritsFromNotObjectTest extends PubPackageResolutionTest {
-  test_classDeclaration_extends() async {
+  test_classAlias_class_extends() async {
     await assertErrorsInCode(r'''
 class A {}
 class B extends A {}
-class C extends Object with B {}
+class C = Object with B;
 ''', [
-      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 60, 1),
+      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 54, 1),
     ]);
   }
 
-  test_classDeclaration_extends_new_syntax() async {
-    await assertNoErrorsInCode(r'''
+  test_classAlias_class_with() async {
+    await assertErrorsInCode(r'''
 class A {}
-mixin B on A {}
-class C extends A with B {}
-''');
+class B extends Object with A {}
+class C = Object with B;
+''', [
+      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 66, 1),
+    ]);
   }
 
-  test_classDeclaration_mixTypeAlias() async {
+  test_classAlias_classAlias_with() async {
     await assertNoErrorsInCode(r'''
 class A {}
 class B = Object with A;
-class C extends Object with B {}
+class C = Object with B;
 ''');
   }
 
-  test_classDeclaration_with() async {
+  test_classAlias_classAlias_with2() async {
     await assertErrorsInCode(r'''
 class A {}
-class B extends Object with A {}
-class C extends Object with B {}
+class B {}
+class C = Object with A, B;
+class D = Object with C;
 ''', [
       error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 72, 1),
     ]);
   }
 
-  test_typeAlias_extends() async {
+  test_classAlias_mixin() async {
+    await assertNoErrorsInCode(r'''
+class A {}
+mixin B on A {}
+class C = A with B;
+''');
+  }
+
+  test_classDeclaration_class_extends() async {
     await assertErrorsInCode(r'''
 class A {}
 class B extends A {}
-class C = Object with B;
+class C extends Object with B {}
 ''', [
-      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 54, 1),
+      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 60, 1),
     ]);
   }
 
-  test_typeAlias_extends_new_syntax() async {
+  test_classDeclaration_class_extends_Object() async {
     await assertNoErrorsInCode(r'''
 class A {}
-mixin B on A {}
-class C = A with B;
+class B extends Object {}
+class C extends Object with B {}
 ''');
   }
 
-  test_typeAlias_with() async {
+  test_classDeclaration_class_with() async {
     await assertErrorsInCode(r'''
 class A {}
 class B extends Object with A {}
-class C = Object with B;
+class C extends Object with B {}
 ''', [
-      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 66, 1),
+      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 72, 1),
     ]);
   }
 
-  test_typedef_mixTypeAlias() async {
+  test_classDeclaration_classAlias_with() async {
     await assertNoErrorsInCode(r'''
 class A {}
 class B = Object with A;
-class C = Object with B;
+class C extends Object with B {}
+''');
+  }
+
+  test_classDeclaration_classAlias_with2() async {
+    await assertErrorsInCode(r'''
+class A {}
+class B {}
+class C = Object with A, B;
+class D extends Object with C {}
+''', [
+      error(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, 78, 1),
+    ]);
+  }
+
+  test_classDeclaration_mixin() async {
+    await assertNoErrorsInCode(r'''
+class A {}
+mixin B on A {}
+class C extends A with B {}
 ''');
   }
 }