[cfe] Always query for ranked superclass info in least upper bound

Previously, the info was inconsistently queried, leading to
nondeterministic behaviors.

Closes #61791

Change-Id: I5d47d0f29b0e78d2834ae3c5793fd05171cf9156
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/457360
Commit-Queue: Chloe Stefantsova <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>
Auto-Submit: Chloe Stefantsova <[email protected]>

Author: chloestefantsova

pkg/front_end/testcases/inference/issue61791.dart

@@ -0,0 +1,16 @@
+// 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.
+
+class A {}
+
+extension type E1(A a) implements A {}
+
+class B extends A {}
+
+extension type E2(B b) implements B, E1 {}
+
+test(E2 e) {
+  var list1 = ["", e];
+  var list2 = ["", e];
+}

pkg/front_end/testcases/inference/issue61791.dart.strong.expect

@@ -0,0 +1,40 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+class B extends self::A {
+  synthetic constructor •() → self::B
+    : super self::A::•()
+    ;
+}
+extension type E1(self::A a) implements self::A {
+  abstract extension-type-member representation-field get a() → self::A;
+  constructor • = self::E1|constructor#;
+  constructor tearoff • = self::E1|constructor#_#new#tearOff;
+}
+extension type E2(self::B b) implements self::B, self::E1 /* erasure=self::A */ {
+  abstract extension-type-member representation-field get b() → self::B;
+  constructor • = self::E2|constructor#;
+  constructor tearoff • = self::E2|constructor#_#new#tearOff;
+}
+static extension-type-member method E1|constructor#(self::A a) → self::E1 /* erasure=self::A */ {
+  lowered final self::E1 /* erasure=self::A */ #this = a;
+  return #this;
+}
+static extension-type-member synthetic method E1|constructor#_#new#tearOff(self::A a) → self::E1 /* erasure=self::A */
+  return self::E1|constructor#(a);
+static extension-type-member method E2|constructor#(self::B b) → self::E2 /* erasure=self::B */ {
+  lowered final self::E2 /* erasure=self::B */ #this = b;
+  return #this;
+}
+static extension-type-member synthetic method E2|constructor#_#new#tearOff(self::B b) → self::E2 /* erasure=self::B */
+  return self::E2|constructor#(b);
+static method test(self::E2 /* erasure=self::B */ e) → dynamic {
+  core::List<core::Object> list1 = <core::Object>["", e];
+  core::List<core::Object> list2 = <core::Object>["", e];
+}

pkg/front_end/testcases/inference/issue61791.dart.strong.modular.expect

@@ -0,0 +1,40 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+class B extends self::A {
+  synthetic constructor •() → self::B
+    : super self::A::•()
+    ;
+}
+extension type E1(self::A a) implements self::A {
+  abstract extension-type-member representation-field get a() → self::A;
+  constructor • = self::E1|constructor#;
+  constructor tearoff • = self::E1|constructor#_#new#tearOff;
+}
+extension type E2(self::B b) implements self::B, self::E1 /* erasure=self::A */ {
+  abstract extension-type-member representation-field get b() → self::B;
+  constructor • = self::E2|constructor#;
+  constructor tearoff • = self::E2|constructor#_#new#tearOff;
+}
+static extension-type-member method E1|constructor#(self::A a) → self::E1 /* erasure=self::A */ {
+  lowered final self::E1 /* erasure=self::A */ #this = a;
+  return #this;
+}
+static extension-type-member synthetic method E1|constructor#_#new#tearOff(self::A a) → self::E1 /* erasure=self::A */
+  return self::E1|constructor#(a);
+static extension-type-member method E2|constructor#(self::B b) → self::E2 /* erasure=self::B */ {
+  lowered final self::E2 /* erasure=self::B */ #this = b;
+  return #this;
+}
+static extension-type-member synthetic method E2|constructor#_#new#tearOff(self::B b) → self::E2 /* erasure=self::B */
+  return self::E2|constructor#(b);
+static method test(self::E2 /* erasure=self::B */ e) → dynamic {
+  core::List<core::Object> list1 = <core::Object>["", e];
+  core::List<core::Object> list2 = <core::Object>["", e];
+}

pkg/front_end/testcases/inference/issue61791.dart.strong.outline.expect

@@ -0,0 +1,32 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    ;
+}
+class B extends self::A {
+  synthetic constructor •() → self::B
+    ;
+}
+extension type E1(self::A a) implements self::A {
+  abstract extension-type-member representation-field get a() → self::A;
+  constructor • = self::E1|constructor#;
+  constructor tearoff • = self::E1|constructor#_#new#tearOff;
+}
+extension type E2(self::B b) implements self::B, self::E1 /* erasure=self::A */ {
+  abstract extension-type-member representation-field get b() → self::B;
+  constructor • = self::E2|constructor#;
+  constructor tearoff • = self::E2|constructor#_#new#tearOff;
+}
+static extension-type-member method E1|constructor#(self::A a) → self::E1 /* erasure=self::A */
+  ;
+static extension-type-member synthetic method E1|constructor#_#new#tearOff(self::A a) → self::E1 /* erasure=self::A */
+  return self::E1|constructor#(a);
+static extension-type-member method E2|constructor#(self::B b) → self::E2 /* erasure=self::B */
+  ;
+static extension-type-member synthetic method E2|constructor#_#new#tearOff(self::B b) → self::E2 /* erasure=self::B */
+  return self::E2|constructor#(b);
+static method test(self::E2 /* erasure=self::B */ e) → dynamic
+  ;

pkg/front_end/testcases/inference/issue61791.dart.strong.transformed.expect

@@ -0,0 +1,40 @@
+library;
+import self as self;
+import "dart:core" as core;
+
+class A extends core::Object {
+  synthetic constructor •() → self::A
+    : super core::Object::•()
+    ;
+}
+class B extends self::A {
+  synthetic constructor •() → self::B
+    : super self::A::•()
+    ;
+}
+extension type E1(self::A a) implements self::A {
+  abstract extension-type-member representation-field get a() → self::A;
+  constructor • = self::E1|constructor#;
+  constructor tearoff • = self::E1|constructor#_#new#tearOff;
+}
+extension type E2(self::B b) implements self::B, self::E1 /* erasure=self::A */ {
+  abstract extension-type-member representation-field get b() → self::B;
+  constructor • = self::E2|constructor#;
+  constructor tearoff • = self::E2|constructor#_#new#tearOff;
+}
+static extension-type-member method E1|constructor#(self::A a) → self::E1 /* erasure=self::A */ {
+  lowered final self::E1 /* erasure=self::A */ #this = a;
+  return #this;
+}
+static extension-type-member synthetic method E1|constructor#_#new#tearOff(self::A a) → self::E1 /* erasure=self::A */
+  return self::E1|constructor#(a);
+static extension-type-member method E2|constructor#(self::B b) → self::E2 /* erasure=self::B */ {
+  lowered final self::E2 /* erasure=self::B */ #this = b;
+  return #this;
+}
+static extension-type-member synthetic method E2|constructor#_#new#tearOff(self::B b) → self::E2 /* erasure=self::B */
+  return self::E2|constructor#(b);
+static method test(self::E2 /* erasure=self::B */ e) → dynamic {
+  core::List<core::Object> list1 = core::_GrowableList::_literal2<core::Object>("", e);
+  core::List<core::Object> list2 = core::_GrowableList::_literal2<core::Object>("", e);
+}

pkg/front_end/testcases/inference/issue61791.dart.textual_outline.expect

@@ -0,0 +1,9 @@
+class A {}
+
+extension type E1(A a) implements A {}
+
+class B extends A {}
+
+extension type E2(B b) implements B, E1 {}
+
+test(E2 e) {}

pkg/front_end/testcases/inference/issue61791.dart.textual_outline_modelled.expect

@@ -0,0 +1,9 @@
+class A {}
+
+class B extends A {}
+
+extension type E1(A a) implements A {}
+
+extension type E2(B b) implements B, E1 {}
+
+test(E2 e) {}

pkg/kernel/lib/class_hierarchy.dart

@@ -762,10 +762,12 @@ class ClosedWorldClassHierarchy
   }
 
   List<_ClassInfo> _getRankedSuperclassInfos(_ClassInfo info) {
-    if (info.leastUpperBoundInfos != null) return info.leastUpperBoundInfos!;
+    if (info._rankedSuperclassInfos != null) {
+      return info._rankedSuperclassInfos!;
+    }
     _LubHeap heap = new _LubHeap()..add(info);
     List<_ClassInfo> chain = <_ClassInfo>[];
-    info.leastUpperBoundInfos = chain;
+    info._rankedSuperclassInfos = chain;
     _ClassInfo? lastInfo = null;
     while (heap.isNotEmpty) {
       _ClassInfo nextInfo = heap.remove();
@@ -792,18 +794,16 @@ class ClosedWorldClassHierarchy
 
   List<_ClassInfo> _getCombinedRankedSuperclassInfosFromList(
       List<_ClassInfo> infos) {
-    if (infos.length == 1 && infos.single.leastUpperBoundInfos != null) {
-      return infos.single.leastUpperBoundInfos!;
+    if (infos.length == 1 && infos.single._rankedSuperclassInfos != null) {
+      return infos.single._rankedSuperclassInfos!;
     }
 
     _LubHeap heap = new _LubHeap();
     for (_ClassInfo info in infos) {
       heap.add(info);
-      if (info.leastUpperBoundInfos == null) {
-        List<_ClassInfo> chainForInfo = _getRankedSuperclassInfos(info);
-        for (_ClassInfo fromChain in chainForInfo) {
-          heap.add(fromChain);
-        }
+      List<_ClassInfo> chainForInfo = _getRankedSuperclassInfos(info);
+      for (_ClassInfo fromChain in chainForInfo) {
+        heap.add(fromChain);
       }
     }
 
@@ -1857,7 +1857,8 @@ class _ClassInfo {
   late final Uint32List superclassIntervalList;
   late final Uint32List supertypeIntervalList;
 
-  List<_ClassInfo>? leastUpperBoundInfos;
+  /// Cached result of [ClosedWorldClassHierarchy._getRankedSuperclassInfos].
+  List<_ClassInfo>? _rankedSuperclassInfos;
 
   /// Maps generic supertype classes to the instantiations implemented by this
   /// class.

pkg/kernel/lib/src/standard_bounds.dart

@@ -893,19 +893,19 @@ mixin StandardBounds {
 
       int computeExtensionTypeDeclarationDepth(
           ExtensionTypeDeclaration extensionTypeDeclaration,
-          List<InterfaceType> superInterfaceType) {
+          List<InterfaceType> superInterfaceTypes) {
         int? depth = extensionTypeDeclarationDepth[extensionTypeDeclaration];
         if (depth == null) {
           int maxDepth = 0;
           for (DartType implemented in extensionTypeDeclaration.implements) {
             if (implemented is ExtensionType) {
               int supertypeDepth = computeExtensionTypeDeclarationDepth(
-                  implemented.extensionTypeDeclaration, superInterfaceType);
+                  implemented.extensionTypeDeclaration, superInterfaceTypes);
               if (supertypeDepth >= maxDepth) {
                 maxDepth = supertypeDepth + 1;
               }
             } else if (implemented is InterfaceType) {
-              superInterfaceType.add(implemented);
+              superInterfaceTypes.add(implemented);
             }
           }
           depth = extensionTypeDeclarationDepth[extensionTypeDeclaration] =