[model] Adjust distance from top calculations in UP in Analyzer

Closes #61218

Change-Id: If50ca1619165f8060fcf18594b6c6f7ab7a4635c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/448382
Commit-Queue: Chloe Stefantsova <[email protected]>
Reviewed-by: Erik Ernst <[email protected]>
Reviewed-by: Paul Berry <[email protected]>

Author: chloestefantsova

pkg/analyzer/lib/src/dart/element/least_upper_bound.dart

@@ -268,6 +268,34 @@ class InterfaceLeastUpperBoundHelper {
         visitedElements,
       );
 
+      // Since mixin applications involve only one mixin, multiple mixins induce
+      // multiple intermediate application classes. Consider the following
+      // example:
+      //
+      //     class A extends B with M1, M2, M3 {}
+      //
+      // Applying M1, M2, and M3 to B results in the following chain of
+      // declarations.
+      //
+      //     abstract class _A&B&M1 extends B implements M1 {}
+      //     abstract class _A&B&M1&M2 extends _A&B&M1 implements M2 {}
+      //     abstract class _A&B&M1&M2&M3 extends _AA&B&M1&M2 implements M3 {}
+      //     class A extends _A&B&M1&M2&M3 {}
+      //
+      // Each of the intermediate applications increase the distance to the top
+      // type by 1.
+      //
+      // Note that named mixin applications are different in that the last
+      // application is the named application itself, so its distance from the
+      // top type is shorter by 1. Consider the following example.
+      //
+      //     class A = B with M1, M2, M3;
+      //
+      // It will result in the following chain of declarations.
+      //
+      //     abstract class _A&B&M1 extends B implements M1 {}
+      //     abstract class _A&B&M1&M2 extends _A&B&M1 implements M2 {}
+      //     class A extends _A&B&M1&M2 implements M3 {}
       var mixins = element.mixins;
       for (var i = 0; i < mixins.length; i++) {
         // class _X&S&M extends S implements M {}
@@ -280,6 +308,12 @@ class InterfaceLeastUpperBoundHelper {
         // For this synthetic class representing the mixin application.
         superLength++;
       }
+      if (mixins.isNotEmpty &&
+          element is ClassElementImpl &&
+          element.isMixinApplication) {
+        // In case of named mixin application, reduce the distance by 1.
+        superLength--;
+      }
 
       longestPath = max(longestPath, 1 + superLength);
     } finally {

tests/language/inference/issue_61218_2_test.dart

@@ -0,0 +1,65 @@
+// Copyright (c) 2025, 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 '../static_type_helper.dart';
+
+class A {} // Distance from the top type: 2 (Object? -> Object -> A).
+
+class B1 {} // Distance from the top type: 2.
+
+class B2 extends B1 {} // Distance from the top type: 3.
+
+mixin M1 {} // Distance from the top type: 2.
+
+mixin M2 implements B2 {} // Distance from the top type: 4.
+
+mixin M3 {} // Distance from the top type: 2.
+
+// The following class hierarchy is synthesized:
+//
+//   - Object.
+//       - Distance from the top type: 1.
+//   - A extends Object.
+//       - Distance from the top type: 2.
+//   - _C&A&M1 extends A implements M1 (anonymous mixin application).
+//       - Distance from the top type: 3.
+//   - _C&A&M1&M2 extends _C&A&M1 implements M2 (anonymous).
+//       - Distance from the top type: 5.
+//       - _Note that M2 is of distance 4 from the top type._
+//   - C extends _C&A&M1&M2 implements M3 (named mixin application).
+//       - Distance from the top type: 6.
+class C1 = A with M1, M2, M3;
+
+class C2 extends C1 {} // Distance from the top type: 7.
+
+class D1 {} // Distance from the top type: 2.
+
+class D2 extends D1 {} // Distance from the top type: 3.
+
+class D3 extends D2 {} // Distance from the top type: 4.
+
+class D4 extends D3 {} // Distance from the top type: 5.
+
+class D5 extends D4 {} // Distance from the top type: 6.
+
+class D6 extends D5 {} // Distance from the top type: 7.
+
+class E extends C2 implements D6 {}
+
+class F extends C2 implements D6 {}
+
+test(bool b, E e, F f) {
+  // Both E and F have two immediate supertypes, C2 and D6, of equal distance 7
+  // from the top type. The UP algorithm for interface types rejects both of
+  // them and tries the types closer to the top. The next two types in the
+  // supertype chain are C1 and D5, which are of equals distance 6 from the top
+  // type. Going higher up in the supertype chains, the anonymous mixin
+  // application _C&A&M1&M2 is compared against D4, but anonymous mixin
+  // applications are ignored as potential candidates for the outcome of UP, so
+  // D4 will be chosen.
+  var ef = b ? e : f;
+  ef.expectStaticType<Exactly<D4>>();
+}
+
+main() {}

tests/language/inference/issue_61218_test.dart

@@ -0,0 +1,55 @@
+// Copyright (c) 2025, 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 '../static_type_helper.dart';
+
+class A {} // Distance from the top type: 2 (Object? -> Object -> A).
+
+mixin M {} // Distance from the top type: 2.
+class AM = A with M; // Distance from the top type: 3.
+
+class B extends AM {} // Distance from the top type: 4.
+
+class C {} // Distance from the top type: 2.
+
+class D extends C {} // Distance from the top type: 3.
+
+class E extends D {} // Distance from the top type: 4.
+
+class F1 extends B implements E {}
+
+class F2 extends B implements E {}
+
+// AM2 is desugared as follows:
+//
+//   - _AM2&A&M extends A implements M (anonymous mixin application).
+//   - AM2 extends _AM2&A&M.
+class AM2 extends A with M {} // Distance from the top type: 4.
+
+class B2 extends AM2 {} // Distance from the top type: 5.
+
+class F12 extends B2 implements E {}
+
+class F22 extends B2 implements E {}
+
+void f(bool b, F1 f1, F2 f2, F12 f12, F22 f22) {
+  // F1 and F2 have same two supertypes, B and E. Both of the supertypes are of
+  // distance 4 from the top type. The UP algorithm ignores all of the types of
+  // the same distance in case there are more than one of those. The next types
+  // in the supertype chains are AM and D, which are of equal distance 3 from
+  // the top type and are dismissed by the UP algorithms as potential candidates
+  // for the upper bound. The next types the algorithm tries are A, M, and
+  // C. They all have the same distance 2 from the top type. Finally, their
+  // supertype, which is Object, is yielded as the result.
+  var x = b ? f1 : f2;
+  x.expectStaticType<Exactly<Object>>();
+
+  // F12 and F22 have same two supertypes, B2 and E. However, B2 is of a bigger
+  // distance from the top type than E, so it's chosen as the upper bound by the
+  // algorithm.
+  var x2 = b ? f12 : f22;
+  x2.expectStaticType<Exactly<B2>>();
+}
+
+void main() {}