Fine. Track combined signatures, to support top-merges.

Change-Id: Ia8aad87209f304f03a993db7883eb7c988c2fdf0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/424920
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -80,6 +80,11 @@ class InheritanceManager3 {
   /// Cached instance interfaces for [InterfaceFragmentImpl].
   final Map<InterfaceFragmentImpl, Interface> _interfaces = {};
 
+  /// Tracks signatures from superinterfaces that were combined.
+  /// It is used to track dependencies in manifests.
+  final Map<InterfaceFragmentImpl, Map<Name, List<ExecutableElement2OrMember>>>
+  _combinedSignatures = {};
+
   /// The set of classes that are currently being processed, used to detect
   /// self-referencing cycles.
   final Set<InterfaceFragmentImpl> _processingClasses = {};
@@ -124,6 +129,9 @@ class InheritanceManager3 {
       return null;
     }
 
+    (_combinedSignatures[targetClass] ??= {})[name] =
+        candidates.map((e) => e.asElement2).toList();
+
     if (doTopMerge) {
       var typeSystem = targetClass.library.typeSystem;
       return _topMerge(typeSystem, targetClass, validOverrides);
@@ -786,6 +794,7 @@ class InheritanceManager3 {
       superImplemented: superImplemented,
       superImplemented2: superImplemented2,
       conflicts: conflicts.toFixedList(),
+      combinedSignatures: _combinedSignatures.remove(fragment) ?? {},
     );
   }
 
@@ -985,6 +994,7 @@ class InheritanceManager3 {
       superImplemented: const [],
       superImplemented2: const [],
       conflicts: conflicts.toFixedList(),
+      combinedSignatures: _combinedSignatures.remove(fragment) ?? {},
     );
   }
 
@@ -1057,6 +1067,7 @@ class InheritanceManager3 {
       superImplemented2: [superInterface2],
       conflicts:
           <Conflict>[...superConflicts, ...interfaceConflicts].toFixedList(),
+      combinedSignatures: _combinedSignatures.remove(fragment) ?? {},
     );
   }
 
@@ -1277,6 +1288,7 @@ class Interface {
     superImplemented: const [{}],
     superImplemented2: const [{}],
     conflicts: const [],
+    combinedSignatures: const {},
   );
 
   /// The map of names to their signature in the interface.
@@ -1327,6 +1339,10 @@ class Interface {
   /// members of the class.
   final List<Conflict> conflicts;
 
+  /// Tracks signatures from superinterfaces that were combined.
+  /// It is used to track dependencies in manifests.
+  final Map<Name, List<ExecutableElement2OrMember>> combinedSignatures;
+
   /// The map of names to the most specific signatures from the mixins,
   /// superclasses, or interfaces.
   Map<Name, ExecutableElementOrMember>? inheritedMap;
@@ -1344,6 +1360,7 @@ class Interface {
     required this.superImplemented,
     required this.superImplemented2,
     required this.conflicts,
+    required this.combinedSignatures,
   });
 
   /// The map of declared names to their signatures.

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

@@ -137,7 +137,6 @@ class LibraryManifestBuilder {
       typeParameters,
     ) {
       classItem.declaredMembers.clear();
-      classItem.interface.clear();
       _addInterfaceElementExecutables(
         encodingContext: encodingContext,
         instanceElement: element,
@@ -374,7 +373,6 @@ class LibraryManifestBuilder {
       typeParameters,
     ) {
       mixinItem.declaredMembers.clear();
-      mixinItem.interface.clear();
       _addInterfaceElementExecutables(
         encodingContext: encodingContext,
         instanceElement: element,
@@ -575,6 +573,7 @@ class LibraryManifestBuilder {
 
     // Must be created already.
     var item = declaredItems[element] as InterfaceItem;
+    item.interface.beforeUpdating();
 
     var interface = element.inheritanceManager.getInterface2(element);
     for (var entry in interface.map2.entries) {
@@ -591,9 +590,34 @@ class LibraryManifestBuilder {
         continue;
       }
 
+      var combinedCandidates = interface.combinedSignatures[entry.key];
+      if (combinedCandidates != null) {
+        var candidateElements =
+            combinedCandidates
+                .map((candidate) => candidate.baseElement)
+                .toSet()
+                .toList();
+        if (candidateElements.length == 1) {
+          executable = candidateElements[0];
+        } else {
+          var candidateIds =
+              candidateElements.map((candidate) {
+                return _getInterfaceElementMemberId(candidate);
+              }).toList();
+          var idList = ManifestItemIdList(candidateIds);
+          var id = item.interface.combinedIdsTemp[idList];
+          id ??= ManifestItemId.generate();
+          item.interface.map[lookupName] = id;
+          item.interface.combinedIds[idList] = id;
+          continue;
+        }
+      }
+
       var id = _getInterfaceElementMemberId(executable);
       item.interface.map[lookupName] = id;
     }
+
+    item.interface.afterUpdate();
   }
 
   void _fillInterfaceElementsInterface() {

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

@@ -6,6 +6,7 @@ import 'dart:math';
 
 import 'package:analyzer/src/summary2/data_reader.dart';
 import 'package:analyzer/src/summary2/data_writer.dart';
+import 'package:collection/collection.dart';
 
 /// The globally unique identifier.
 ///
@@ -51,11 +52,46 @@ class ManifestItemId {
     sink.writeUInt32(randomBits);
   }
 
+  static List<ManifestItemId> readList(SummaryDataReader reader) {
+    return reader.readTypedList(() => ManifestItemId.read(reader));
+  }
+
   static ManifestItemId? readOptional(SummaryDataReader reader) {
     return reader.readOptionalObject(() => ManifestItemId.read(reader));
   }
 }
 
+class ManifestItemIdList {
+  final List<ManifestItemId> ids;
+
+  ManifestItemIdList(this.ids);
+
+  factory ManifestItemIdList.read(SummaryDataReader reader) {
+    return ManifestItemIdList(ManifestItemId.readList(reader));
+  }
+
+  @override
+  int get hashCode {
+    return const ListEquality<ManifestItemId>().hash(ids);
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is ManifestItemIdList &&
+        const ListEquality<ManifestItemId>().equals(other.ids, ids);
+  }
+
+  @override
+  String toString() {
+    return '[${ids.join(', ')}]';
+  }
+
+  void write(BufferedSink sink) {
+    sink.writeList(ids, (id) => id.write(sink));
+  }
+}
+
 extension ManifestItemIdExtension on ManifestItemId? {
   void writeOptional(BufferedSink sink) {
     sink.writeOptionalObject(this, (id) {

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

@@ -493,22 +493,48 @@ class ManifestInterface {
   /// The map of names to their IDs in the interface.
   final Map<LookupName, ManifestItemId> map;
 
-  ManifestInterface({required this.map});
+  /// Key: IDs of method declarations.
+  /// Value: ID assigned last time.
+  /// When the same signatures merge, the result is the same.
+  Map<ManifestItemIdList, ManifestItemId> combinedIds = {};
+
+  /// We move [combinedIds] into here during building the manifest, so that
+  /// we can fill [combinedIds] with new entries.
+  Map<ManifestItemIdList, ManifestItemId> combinedIdsTemp = {};
+
+  ManifestInterface({required this.map, required this.combinedIds});
 
   factory ManifestInterface.empty() {
-    return ManifestInterface(map: {});
+    return ManifestInterface(map: {}, combinedIds: {});
   }
 
   factory ManifestInterface.read(SummaryDataReader reader) {
-    return ManifestInterface(map: LookupNameIdMapExtension.read(reader));
+    return ManifestInterface(
+      map: LookupNameIdMapExtension.read(reader),
+      combinedIds: reader.readMap(
+        readKey: () => ManifestItemIdList.read(reader),
+        readValue: () => ManifestItemId.read(reader),
+      ),
+    );
   }
 
-  void clear() {
+  void afterUpdate() {
+    combinedIdsTemp = {};
+  }
+
+  void beforeUpdating() {
     map.clear();
+    combinedIdsTemp = combinedIds;
+    combinedIds = {};
   }
 
   void write(BufferedSink sink) {
     map.write(sink);
+    sink.writeMap(
+      combinedIds,
+      writeKey: (key) => key.write(sink),
+      writeValue: (id) => id.write(sink),
+    );
   }
 }