Fine. Track mixin base flag and super-invoked names.

Capture additional mixin semantics in the fine-grained manifest to
improve dependency sensitivity and determinism.

- Add `isBase` to `MixinItem` and include it in encode/read/match/write,
  so manifest IDs change when a mixin’s base modifier changes.
- Record `superInvokedNames` in `MixinItem` as a `List<LookupName>` and
  include it in matching, making the manifest sensitive to whether a
  mixin invokes a member on `super` (getter, setter, or method).
- Canonicalize `superInvokedNames` by sorting them during collection in
  `LibraryBuilder.collectMixinSuperInvokedNames()`, eliminating
  nondeterminism from source reordering.
- Add `SummaryDataReader.readLookupNameList()` to simplify decoding of
  `LookupName` lists.
- Bump `AnalysisDriver.DATA_VERSION` to 532 to reflect the binary format
  change and invalidate incompatible caches.

These changes ensure that altering a mixin’s base status or its use of
`super` correctly affects manifest identity, while simple reordering of
`super` calls does not.

Change-Id: I9147f6505070f28ffbc476acac3cdaaaf55c2fc1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/448000
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -106,7 +106,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 531;
+  static const int DATA_VERSION = 532;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

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

@@ -163,6 +163,10 @@ extension SummaryDataReaderExtension on SummaryDataReader {
     return result;
   }
 
+  List<LookupName> readLookupNameList() {
+    return readTypedList(() => LookupName.read(this));
+  }
+
   Set<LookupName> readLookupNameSet() {
     var length = readUInt30();
     var result = <LookupName>{};

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

@@ -1176,7 +1176,9 @@ class ManifestMetadata {
 }
 
 class MixinItem extends InterfaceItem<MixinElementImpl> {
+  final bool isBase;
   final List<ManifestType> superclassConstraints;
+  final List<LookupName> superInvokedNames;
 
   MixinItem({
     required super.id,
@@ -1193,7 +1195,9 @@ class MixinItem extends InterfaceItem<MixinElementImpl> {
     required super.declaredConstructors,
     required super.inheritedConstructors,
     required super.interface,
+    required this.isBase,
     required this.superclassConstraints,
+    required this.superInvokedNames,
   }) : assert(supertype == null),
        assert(mixins.isEmpty),
        assert(superclassConstraints.isNotEmpty);
@@ -1219,7 +1223,11 @@ class MixinItem extends InterfaceItem<MixinElementImpl> {
         supertype: element.supertype?.encode(context),
         mixins: element.mixins.encode(context),
         interfaces: element.interfaces.encode(context),
+        isBase: element.isBase,
         superclassConstraints: element.superclassConstraints.encode(context),
+        superInvokedNames: element.superInvokedNames
+            .map((name) => name.asLookupName)
+            .toFixedList(),
       );
     });
   }
@@ -1240,20 +1248,29 @@ class MixinItem extends InterfaceItem<MixinElementImpl> {
       mixins: ManifestType.readList(reader),
       interfaces: ManifestType.readList(reader),
       interface: ManifestInterface.read(reader),
+      isBase: reader.readBool(),
       superclassConstraints: ManifestType.readList(reader),
+      superInvokedNames: reader.readLookupNameList(),
     );
   }
 
   @override
   bool match(MatchContext context, MixinElementImpl element) {
     return super.match(context, element) &&
-        superclassConstraints.match(context, element.superclassConstraints);
+        isBase == element.isBase &&
+        superclassConstraints.match(context, element.superclassConstraints) &&
+        const IterableEquality<String>().equals(
+          superInvokedNames.map((lookupName) => lookupName.asString),
+          element.superInvokedNames,
+        );
   }
 
   @override
   void write(BufferedSink sink) {
     super.write(sink);
+    sink.writeBool(isBase);
     superclassConstraints.writeList(sink);
+    superInvokedNames.write(sink);
   }
 }
 

pkg/analyzer/lib/src/summary2/library_builder.dart

@@ -28,6 +28,7 @@ import 'package:analyzer/src/summary2/types_builder.dart';
 import 'package:analyzer/src/util/performance/operation_performance.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
 import 'package:analyzer/src/utilities/extensions/element.dart';
+import 'package:collection/collection.dart';
 
 class DefiningLinkingUnit extends LinkingUnit {
   DefiningLinkingUnit({required super.node, required super.element});
@@ -277,7 +278,7 @@ class LibraryBuilder {
             }
           }
           var fragment = declaration.declaredFragment!;
-          fragment.superInvokedNames = names.toList();
+          fragment.superInvokedNames = names.sorted();
         }
       }
     }