Front end: move anonymous mixin sealed/final inference to checkSupertypes phase.

Previously this step happened during `buildOutlineNodes`, but since
`buildOutlineNodes` happens in source order, this means that anonymous
mixins would only get their sealed and final attributes properly
inferred if they appeared *after* their immediate supertypes in source
order.  By moving this step to `checkSupertypes`, we ensure that the
computation is correct regardless of source order, because
`checkSupertypes` happens in class hierarchy order.

Fixes #52048.

Bug: #52048
Change-Id: Ib9f1f3dafded88681a26f09e4d21dfd44e70dfd3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/297901
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Chloe Stefantsova <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: stereotype441

pkg/front_end/lib/src/fasta/source/source_class_builder.dart

@@ -286,28 +286,6 @@ class SourceClassBuilder extends ClassBuilderImpl
     cls.isInterface = isInterface;
     cls.isFinal = isFinal;
 
-    // Anonymous mixins have to propagate certain class modifiers.
-    if (cls.isAnonymousMixin) {
-      Class? superclass = cls.superclass;
-      Class? mixedInClass = cls.mixedInClass;
-      // If either [superclass] or [mixedInClass] is sealed, the current
-      // anonymous mixin is sealed.
-      if (superclass != null && superclass.isSealed ||
-          mixedInClass != null && mixedInClass.isSealed) {
-        cls.isSealed = true;
-      } else {
-        // Otherwise, if either [superclass] or [mixedInClass] is base or final,
-        // then the current anonymous mixin is final.
-        bool superclassIsBaseOrFinal =
-            superclass != null && (superclass.isBase || superclass.isFinal);
-        bool mixedInClassIsBaseOrFinal = mixedInClass != null &&
-            (mixedInClass.isBase || mixedInClass.isFinal);
-        if (superclassIsBaseOrFinal || mixedInClassIsBaseOrFinal) {
-          cls.isFinal = true;
-        }
-      }
-    }
-
     if (interfaceBuilders != null) {
       for (int i = 0; i < interfaceBuilders!.length; ++i) {
         interfaceBuilders![i] = _checkSupertype(interfaceBuilders![i]);
@@ -641,6 +619,28 @@ class SourceClassBuilder extends ClassBuilderImpl
     // Moreover, it checks that `FutureOr` and `void` are not among the
     // supertypes and that `Enum` is not implemented by non-abstract classes.
 
+    // Anonymous mixins have to propagate certain class modifiers.
+    if (cls.isAnonymousMixin) {
+      Class? superclass = cls.superclass;
+      Class? mixedInClass = cls.mixedInClass;
+      // If either [superclass] or [mixedInClass] is sealed, the current
+      // anonymous mixin is sealed.
+      if (superclass != null && superclass.isSealed ||
+          mixedInClass != null && mixedInClass.isSealed) {
+        cls.isSealed = true;
+      } else {
+        // Otherwise, if either [superclass] or [mixedInClass] is base or final,
+        // then the current anonymous mixin is final.
+        bool superclassIsBaseOrFinal =
+            superclass != null && (superclass.isBase || superclass.isFinal);
+        bool mixedInClassIsBaseOrFinal = mixedInClass != null &&
+            (mixedInClass.isBase || mixedInClass.isFinal);
+        if (superclassIsBaseOrFinal || mixedInClassIsBaseOrFinal) {
+          cls.isFinal = true;
+        }
+      }
+    }
+
     ClassHierarchyNode classHierarchyNode =
         hierarchyBuilder.getNodeFromClass(cls);
     if (libraryBuilder.libraryFeatures.enhancedEnums.isEnabled && !isEnum) {

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart

@@ -0,0 +1,22 @@
+// 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.
+
+main() {
+  f(B());
+}
+
+f(A a) {
+  switch (a) {
+    case B():
+      print("It's a B");
+  }
+}
+
+class B extends A with M {
+  B();
+}
+
+sealed class A {}
+
+mixin M {}

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.strong.expect

@@ -0,0 +1,37 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+abstract sealed class _B&A&M = self::A with self::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_B&A&M
+    : super self::A::•()
+    ;
+}
+class B extends self::_B&A&M {
+  constructor •() → self::B
+    : super self::_B&A&M::•()
+    ;
+}
+abstract sealed class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+}
+static method main() → dynamic {
+  self::f(new self::B::•());
+}
+static method f(self::A a) → dynamic {
+  #L1:
+  {
+    final synthesized self::A #0#0 = a;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B) {
+        {
+          core::print("It's a B");
+        }
+      }
+    }
+  }
+}

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.strong.transformed.expect

@@ -0,0 +1,37 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+abstract sealed class _B&A&M extends self::A implements self::M /*isAnonymousMixin,isEliminatedMixin*/  {
+  synthetic constructor •() → self::_B&A&M
+    : super self::A::•()
+    ;
+}
+class B extends self::_B&A&M {
+  constructor •() → self::B
+    : super self::_B&A&M::•()
+    ;
+}
+abstract sealed class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+}
+static method main() → dynamic {
+  self::f(new self::B::•());
+}
+static method f(self::A a) → dynamic {
+  #L1:
+  {
+    final synthesized self::A #0#0 = a;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B) {
+        {
+          core::print("It's a B");
+        }
+      }
+    }
+  }
+}

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.textual_outline.expect

@@ -0,0 +1,10 @@
+main() {}
+f(A a) {}
+
+class B extends A with M {
+  B();
+}
+
+sealed class A {}
+
+mixin M {}

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.textual_outline_modelled.expect

@@ -0,0 +1,9 @@
+class B extends A with M {
+  B();
+}
+
+f(A a) {}
+main() {}
+mixin M {}
+
+sealed class A {}

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.weak.expect

@@ -0,0 +1,40 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+abstract sealed class _B&A&M = self::A with self::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_B&A&M
+    : super self::A::•()
+    ;
+}
+class B extends self::_B&A&M {
+  constructor •() → self::B
+    : super self::_B&A&M::•()
+    ;
+}
+abstract sealed class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+}
+static method main() → dynamic {
+  self::f(new self::B::•());
+}
+static method f(self::A a) → dynamic {
+  #L1:
+  {
+    final synthesized self::A #0#0 = a;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B) {
+        {
+          core::print("It's a B");
+        }
+      }
+      break #L1;
+    }
+    throw new _in::ReachabilityError::•("`null` encountered as case in a switch statement with a non-nullable type.");
+  }
+}

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.weak.modular.expect

@@ -0,0 +1,40 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+abstract sealed class _B&A&M = self::A with self::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_B&A&M
+    : super self::A::•()
+    ;
+}
+class B extends self::_B&A&M {
+  constructor •() → self::B
+    : super self::_B&A&M::•()
+    ;
+}
+abstract sealed class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+}
+static method main() → dynamic {
+  self::f(new self::B::•());
+}
+static method f(self::A a) → dynamic {
+  #L1:
+  {
+    final synthesized self::A #0#0 = a;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B) {
+        {
+          core::print("It's a B");
+        }
+      }
+      break #L1;
+    }
+    throw new _in::ReachabilityError::•("`null` encountered as case in a switch statement with a non-nullable type.");
+  }
+}

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.weak.outline.expect

@@ -0,0 +1,23 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+
+abstract sealed class _B&A&M = self::A with self::M /*isAnonymousMixin*/  {
+  synthetic constructor •() → self::_B&A&M
+    : super self::A::•()
+    ;
+}
+class B extends self::_B&A&M {
+  constructor •() → self::B
+    ;
+}
+abstract sealed class A extends core::Object {
+  synthetic constructor •() → self::A
+    ;
+}
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+}
+static method main() → dynamic
+  ;
+static method f(self::A a) → dynamic
+  ;

pkg/front_end/testcases/patterns/exhaustiveness/issue52048.dart.weak.transformed.expect

@@ -0,0 +1,40 @@
+library /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:_internal" as _in;
+
+abstract sealed class _B&A&M extends self::A implements self::M /*isAnonymousMixin,isEliminatedMixin*/  {
+  synthetic constructor •() → self::_B&A&M
+    : super self::A::•()
+    ;
+}
+class B extends self::_B&A&M {
+  constructor •() → self::B
+    : super self::_B&A&M::•()
+    ;
+}
+abstract sealed class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+}
+static method main() → dynamic {
+  self::f(new self::B::•());
+}
+static method f(self::A a) → dynamic {
+  #L1:
+  {
+    final synthesized self::A #0#0 = a;
+    {
+      if(#0#0 is{ForNonNullableByDefault} self::B) {
+        {
+          core::print("It's a B");
+        }
+      }
+      break #L1;
+    }
+    throw new _in::ReachabilityError::•("`null` encountered as case in a switch statement with a non-nullable type.");
+  }
+}