Fine. Record InstanceElement.methods access.

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

Author: scheglov

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

@@ -4535,7 +4535,10 @@ abstract class InstanceElementImpl2 extends ElementImpl2
   MetadataImpl get metadata2 => firstFragment.metadata2;
 
   @override
+  @trackedDirectlyExpensive
   List<MethodElementImpl2> get methods {
+    globalResultRequirements?.record_instanceElement_methods(element: this);
+
     return firstFragment.methods.map((e) => e.asElement2).toList();
   }
 
@@ -4613,7 +4616,15 @@ abstract class InstanceElementImpl2 extends ElementImpl2
       name: name,
     );
 
-    return methods.firstWhereOrNull((e) => e.lookupName == name);
+    return globalResultRequirements.withoutRecording(
+      reason: r'''
+The result depends only on the requested method, which we have already
+recorded above.
+''',
+      operation: () {
+        return methods.firstWhereOrNull((e) => e.lookupName == name);
+      },
+    );
   }
 
   @Deprecated('Use getMethod instead')

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

@@ -82,6 +82,10 @@ class ManifestItemIdList {
         const ListEquality<ManifestItemId>().equals(other.ids, ids);
   }
 
+  bool equalToIterable(Iterable<ManifestItemId> other) {
+    return const IterableEquality<ManifestItemId>().equals(ids, other);
+  }
+
   @override
   String toString() {
     return '[${ids.join(', ')}]';
@@ -90,12 +94,22 @@ class ManifestItemIdList {
   void write(BufferedSink sink) {
     sink.writeList(ids, (id) => id.write(sink));
   }
+
+  static ManifestItemIdList? readOptional(SummaryDataReader reader) {
+    return reader.readOptionalObject(() => ManifestItemIdList.read(reader));
+  }
 }
 
 extension ManifestItemIdExtension on ManifestItemId? {
   void writeOptional(BufferedSink sink) {
-    sink.writeOptionalObject(this, (id) {
-      id.write(sink);
+    sink.writeOptionalObject(this, (it) {
+      it.write(sink);
     });
   }
 }
+
+extension ManifestItemIdListOrNullExtension on ManifestItemIdList? {
+  void writeOptional(BufferedSink sink) {
+    sink.writeOptionalObject(this, (it) => it.write(sink));
+  }
+}

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

@@ -76,6 +76,20 @@ class InstanceMethodIdMismatch extends RequirementFailure {
   });
 }
 
+class InstanceMethodIdsMismatch extends RequirementFailure {
+  final Uri libraryUri;
+  final LookupName interfaceName;
+  final ManifestItemIdList expectedIds;
+  final ManifestItemIdList actualIds;
+
+  InstanceMethodIdsMismatch({
+    required this.libraryUri,
+    required this.interfaceName,
+    required this.expectedIds,
+    required this.actualIds,
+  });
+}
+
 class InterfaceConstructorIdMismatch extends RequirementFailure {
   final Uri libraryUri;
   final LookupName interfaceName;

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

@@ -202,11 +202,14 @@ class InstanceItemRequirements {
   final Map<LookupName, ManifestItemId?> requestedSetters;
   final Map<LookupName, ManifestItemId?> requestedMethods;
 
+  ManifestItemIdList? allDeclaredMethods;
+
   InstanceItemRequirements({
     required this.requestedFields,
     required this.requestedGetters,
     required this.requestedSetters,
     required this.requestedMethods,
+    required this.allDeclaredMethods,
   });
 
   factory InstanceItemRequirements.empty() {
@@ -215,6 +218,7 @@ class InstanceItemRequirements {
       requestedGetters: {},
       requestedSetters: {},
       requestedMethods: {},
+      allDeclaredMethods: null,
     );
   }
 
@@ -224,6 +228,7 @@ class InstanceItemRequirements {
       requestedGetters: reader.readNameToIdMap(),
       requestedSetters: reader.readNameToIdMap(),
       requestedMethods: reader.readNameToIdMap(),
+      allDeclaredMethods: ManifestItemIdList.readOptional(reader),
     );
   }
 
@@ -232,6 +237,7 @@ class InstanceItemRequirements {
     sink.writeNameToIdMap(requestedGetters);
     sink.writeNameToIdMap(requestedSetters);
     sink.writeNameToIdMap(requestedMethods);
+    allDeclaredMethods.writeOptional(sink);
   }
 }
 
@@ -321,6 +327,8 @@ class RequirementsManifest {
 
   final List<LibraryExportRequirements> exportRequirements = [];
 
+  int _recordingLockLevel = 0;
+
   RequirementsManifest();
 
   factory RequirementsManifest.read(SummaryDataReader reader) {
@@ -491,6 +499,19 @@ class RequirementsManifest {
             );
           }
         }
+
+        if (requirements.allDeclaredMethods case var required?) {
+          var actualItems = instanceItem.declaredMethods.values;
+          var actualIds = actualItems.map((item) => item.id);
+          if (!required.equalToIterable(actualIds)) {
+            return InstanceMethodIdsMismatch(
+              libraryUri: libraryUri,
+              interfaceName: instanceName,
+              expectedIds: required,
+              actualIds: ManifestItemIdList(actualIds.toList()),
+            );
+          }
+        }
       }
     }
 
@@ -666,6 +687,24 @@ class RequirementsManifest {
     requirements.requestedSetters[methodName] = methodId;
   }
 
+  void record_instanceElement_methods({required InstanceElementImpl2 element}) {
+    if (_recordingLockLevel != 0) {
+      return;
+    }
+
+    var itemRequirements = _getInstanceItem(element);
+    if (itemRequirements == null) {
+      return;
+    }
+
+    var item = itemRequirements.item;
+    var requirements = itemRequirements.requirements;
+
+    requirements.allDeclaredMethods ??= ManifestItemIdList(
+      item.declaredMethods.values.map((item) => item.id).toList(),
+    );
+  }
+
   /// Record that a member with [nameObj] was requested from the interface
   /// of [element]. The [methodElement] is used for consistency checking.
   void record_interface_getMember({
@@ -973,6 +1012,25 @@ class _InterfaceItemWithRequirements {
   });
 }
 
+extension RequirementsManifestExtension on RequirementsManifest? {
+  T withoutRecording<T>({
+    required String reason,
+    required T Function() operation,
+  }) {
+    var self = this;
+    if (self == null) {
+      return operation();
+    } else {
+      self._recordingLockLevel++;
+      try {
+        return operation();
+      } finally {
+        self._recordingLockLevel--;
+      }
+    }
+  }
+}
+
 extension _BufferedSinkExtension on BufferedSink {
   void writeNameToIdMap(Map<LookupName, ManifestItemId?> map) {
     writeMap(