Fine. Record requesting the whole interface.

We give the interface its own ID to track its changes.

We also stop collecting requirements of a summary bundle _after_
computing library manifests for it, because any data that we put into
library manifests depends on what we requested while computing it,
not much different than the summary / elements themselves. Specifically,
interfaces for classes have `map` of all class members, and it
depends on the interfaces of superclasses. And we ask for interfaces
of classes only when computing library manifests, somehow we avoided
doing this while linking libraries.

test_dependency_class_interface_addMethod would not work without
these changes.

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

Author: scheglov

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

@@ -218,7 +218,6 @@ class LibraryContext {
                 inputLibraryManifests: inputLibraryManifests,
               );
             });
-            globalResultRequirements = null;
             linkedBytes = linkResult.resolutionBytes;
 
             var newLibraryManifests = <Uri, LibraryManifest>{};
@@ -235,6 +234,7 @@ class LibraryContext {
               elementFactory: elementFactory,
               libraryUriSet: cycle.libraryUris,
             );
+            globalResultRequirements = null;
             requirements.removeReqForLibs(cycle.libraryUris);
 
             bundleEntry = LinkedBundleEntry(

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

@@ -287,6 +287,7 @@ class InheritanceManager3 {
   @experimental
   Interface getInterface2(InterfaceElement element) {
     element as InterfaceElementImpl2; // TODO(scheglov): remove cast
+    globalResultRequirements?.record_interface_all(element: element);
     return getInterface(element.asElement);
   }
 

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

@@ -12,6 +12,7 @@ import 'package:analyzer/src/fine/manifest_type.dart';
 import 'package:analyzer/src/summary2/data_reader.dart';
 import 'package:analyzer/src/summary2/data_writer.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
+import 'package:collection/collection.dart';
 import 'package:meta/meta.dart';
 
 class ClassItem extends InterfaceItem<ClassElementImpl2> {
@@ -987,8 +988,16 @@ class ManifestAnnotation {
 /// type. So, any such code depends on the header of the class, so includes
 /// the type arguments for the class that declares the inherited member.
 class ManifestInterface {
+  /// The ID of the interface, stays the same if all information in the
+  /// interface is the same.
+  ManifestItemId id;
+
   /// The map of names to their IDs in the interface.
-  final Map<LookupName, ManifestItemId> map;
+  Map<LookupName, ManifestItemId> map;
+
+  /// We move [map] into here during building the manifest, so that we can
+  /// compare after building, and decide if [id] should be updated.
+  Map<LookupName, ManifestItemId> mapPrevious = {};
 
   /// Key: IDs of method declarations.
   /// Value: ID assigned last time.
@@ -999,14 +1008,23 @@ class ManifestInterface {
   /// we can fill [combinedIds] with new entries.
   Map<ManifestItemIdList, ManifestItemId> combinedIdsTemp = {};
 
-  ManifestInterface({required this.map, required this.combinedIds});
+  ManifestInterface({
+    required this.id,
+    required this.map,
+    required this.combinedIds,
+  });
 
   factory ManifestInterface.empty() {
-    return ManifestInterface(map: {}, combinedIds: {});
+    return ManifestInterface(
+      id: ManifestItemId.generate(),
+      map: {},
+      combinedIds: {},
+    );
   }
 
   factory ManifestInterface.read(SummaryDataReader reader) {
     return ManifestInterface(
+      id: ManifestItemId.read(reader),
       map: reader.readLookupNameToIdMap(),
       combinedIds: reader.readMap(
         readKey: () => ManifestItemIdList.read(reader),
@@ -1016,16 +1034,25 @@ class ManifestInterface {
   }
 
   void afterUpdate() {
+    const mapEquality = MapEquality<LookupName, ManifestItemId>();
+    if (!mapEquality.equals(map, mapPrevious)) {
+      id = ManifestItemId.generate();
+    }
+    mapPrevious = {};
+
     combinedIdsTemp = {};
   }
 
   void beforeUpdating() {
-    map.clear();
+    mapPrevious = map;
+    map = {};
+
     combinedIdsTemp = combinedIds;
     combinedIds = {};
   }
 
   void write(BufferedSink sink) {
+    id.write(sink);
     map.write(sink);
     sink.writeMap(
       combinedIds,

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

@@ -106,6 +106,20 @@ class InterfaceConstructorIdMismatch extends RequirementFailure {
   });
 }
 
+class InterfaceIdMismatch extends RequirementFailure {
+  final Uri libraryUri;
+  final LookupName interfaceName;
+  final ManifestItemId expectedId;
+  final ManifestItemId actualId;
+
+  InterfaceIdMismatch({
+    required this.libraryUri,
+    required this.interfaceName,
+    required this.expectedId,
+    required this.actualId,
+  });
+}
+
 class LibraryMissing extends RequirementFailure {
   final Uri uri;
 

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

@@ -247,28 +247,38 @@ class InstanceItemRequirements {
 /// Includes all requirements from class-like items: classes, enums,
 /// extension types, mixins.
 class InterfaceItemRequirements {
+  /// If the element was asked for its full interface.
+  ManifestItemId? interfaceId;
+
   final Map<LookupName, ManifestItemId?> constructors;
 
   /// These are "methods" in wide meaning: methods, getters, setters.
   final Map<LookupName, ManifestItemId?> methods;
 
   InterfaceItemRequirements({
+    required this.interfaceId,
     required this.constructors,
     required this.methods,
   });
 
   factory InterfaceItemRequirements.empty() {
-    return InterfaceItemRequirements(constructors: {}, methods: {});
+    return InterfaceItemRequirements(
+      interfaceId: null,
+      constructors: {},
+      methods: {},
+    );
   }
 
   factory InterfaceItemRequirements.read(SummaryDataReader reader) {
     return InterfaceItemRequirements(
+      interfaceId: ManifestItemId.readOptional(reader),
       constructors: reader.readNameToIdMap(),
       methods: reader.readNameToIdMap(),
     );
   }
 
   void write(BufferedSink sink) {
+    interfaceId.writeOptional(sink);
     sink.writeNameToIdMap(constructors);
     sink.writeNameToIdMap(methods);
   }
@@ -538,7 +548,20 @@ class RequirementsManifest {
           );
         }
 
-        var constructors = interfaceEntry.value.constructors;
+        var interfaceRequirements = interfaceEntry.value;
+        if (interfaceRequirements.interfaceId case var expectedId?) {
+          var actualId = interfaceItem.interface.id;
+          if (expectedId != actualId) {
+            return InterfaceIdMismatch(
+              libraryUri: libraryUri,
+              interfaceName: interfaceName,
+              expectedId: expectedId,
+              actualId: actualId,
+            );
+          }
+        }
+
+        var constructors = interfaceRequirements.constructors;
         for (var constructorEntry in constructors.entries) {
           var constructorName = constructorEntry.key;
           var constructorId = interfaceItem.getConstructorId(constructorName);
@@ -554,7 +577,7 @@ class RequirementsManifest {
           }
         }
 
-        var methods = interfaceEntry.value.methods;
+        var methods = interfaceRequirements.methods;
         for (var methodEntry in methods.entries) {
           var methodName = methodEntry.key;
           var methodId = interfaceItem.getInterfaceMethodId(methodName);
@@ -705,6 +728,16 @@ class RequirementsManifest {
     );
   }
 
+  void record_interface_all({required InterfaceElementImpl2 element}) {
+    var itemRequirements = _getInterfaceItem(element);
+    if (itemRequirements == null) {
+      return;
+    }
+
+    var interface = itemRequirements.item.interface;
+    itemRequirements.requirements.interfaceId = interface.id;
+  }
+
   /// Record that a member with [nameObj] was requested from the interface
   /// of [element]. The [methodElement] is used for consistency checking.
   void record_interface_getMember({