Fine. Record requested fields.

Directly with `getField`, or indirectly via getter/setter.

Many `test_dependency_` switched to `instanceFieldIdMismatch` because
almost any use of a getter / setter in code like `x.foo` end up
requesting the field while resolving.

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

Author: scheglov

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

@@ -4436,6 +4436,7 @@ class HideElementCombinatorImpl implements HideElementCombinator {
   }
 }
 
+@elementClass
 abstract class InstanceElementImpl2 extends ElementImpl2
     implements
         InstanceElement,
@@ -4540,11 +4541,18 @@ abstract class InstanceElementImpl2 extends ElementImpl2
   );
 
   @override
+  @trackedDirectly
   FieldElementImpl2? getField2(String name) {
+    globalResultRequirements?.record_instanceElement_getField(
+      element: this,
+      name: name,
+    );
+
     return fields2.firstWhereOrNull((e) => e.name3 == name);
   }
 
   @override
+  @trackedDirectly
   GetterElementImpl? getGetter2(String name) {
     globalResultRequirements?.record_instanceElement_getGetter(
       element: this,
@@ -4555,6 +4563,7 @@ abstract class InstanceElementImpl2 extends ElementImpl2
   }
 
   @override
+  @trackedDirectly
   MethodElementImpl2? getMethod2(String name) {
     globalResultRequirements?.record_instanceElement_getMethod(
       element: this,
@@ -4565,6 +4574,7 @@ abstract class InstanceElementImpl2 extends ElementImpl2
   }
 
   @override
+  @trackedDirectly
   SetterElementImpl? getSetter2(String name) {
     globalResultRequirements?.record_instanceElement_getSetter(
       element: this,
@@ -8469,7 +8479,13 @@ abstract class PropertyAccessorElementImpl2 extends ExecutableElementImpl2
   String? get name3 => firstFragment.name2;
 
   @override
+  @trackedDirectly
   PropertyInducingElementImpl2? get variable3 {
+    globalResultRequirements?.record_propertyAccessorElement_variable(
+      element: this,
+      name: name3,
+    );
+
     return firstFragment.variable2?.element;
   }
 }

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

@@ -104,6 +104,10 @@ sealed class InstanceItem<E extends InstanceElementImpl2>
     return baseNameMembers.constructorId;
   }
 
+  ManifestItemId? getDeclaredFieldId(LookupName name) {
+    return declaredFields[name]?.id;
+  }
+
   ManifestItemId? getDeclaredMemberId(LookupName name) {
     var baseNameMembers = declaredMembers[name.asBaseName];
     if (baseNameMembers == null) {

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

@@ -44,6 +44,22 @@ final class ExportLibraryMissing extends ExportFailure {
   ExportLibraryMissing({required this.uri});
 }
 
+class InstanceFieldIdMismatch extends RequirementFailure {
+  final Uri libraryUri;
+  final LookupName interfaceName;
+  final LookupName fieldName;
+  final ManifestItemId? expectedId;
+  final ManifestItemId? actualId;
+
+  InstanceFieldIdMismatch({
+    required this.libraryUri,
+    required this.interfaceName,
+    required this.fieldName,
+    required this.expectedId,
+    required this.actualId,
+  });
+}
+
 class InstanceMethodIdMismatch extends RequirementFailure {
   final Uri libraryUri;
   final LookupName interfaceName;

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

@@ -190,20 +190,29 @@ final class ExportRequirementShowCombinator
 /// If [InterfaceElementImpl2], there are additional requirements in form
 /// of [InterfaceItemRequirements].
 class InstanceItemRequirements {
+  final Map<LookupName, ManifestItemId?> requestedFields;
+
   /// These are "methods" in wide meaning: methods, getters, setters.
   final Map<LookupName, ManifestItemId?> requestedMethods;
 
-  InstanceItemRequirements({required this.requestedMethods});
+  InstanceItemRequirements({
+    required this.requestedFields,
+    required this.requestedMethods,
+  });
 
   factory InstanceItemRequirements.empty() {
-    return InstanceItemRequirements(requestedMethods: {});
+    return InstanceItemRequirements(requestedFields: {}, requestedMethods: {});
   }
 
   factory InstanceItemRequirements.read(SummaryDataReader reader) {
-    return InstanceItemRequirements(requestedMethods: reader.readNameToIdMap());
+    return InstanceItemRequirements(
+      requestedFields: reader.readNameToIdMap(),
+      requestedMethods: reader.readNameToIdMap(),
+    );
   }
 
   void write(BufferedSink sink) {
+    sink.writeNameToIdMap(requestedFields);
     sink.writeNameToIdMap(requestedMethods);
   }
 }
@@ -349,6 +358,8 @@ class RequirementsManifest {
 
       for (var instanceEntry in libraryEntry.value.entries) {
         var instanceName = instanceEntry.key;
+        var requirements = instanceEntry.value;
+
         var instanceItem = libraryManifest.items[instanceName];
         if (instanceItem is! InstanceItem) {
           return TopLevelNotInterface(
@@ -357,18 +368,32 @@ class RequirementsManifest {
           );
         }
 
-        var methods = instanceEntry.value.requestedMethods;
-        for (var methodEntry in methods.entries) {
-          var methodName = methodEntry.key;
-          var methodId = instanceItem.getDeclaredMemberId(methodName);
+        for (var fieldEntry in requirements.requestedFields.entries) {
+          var name = fieldEntry.key;
+          var expectedId = fieldEntry.value;
+          var currentId = instanceItem.getDeclaredFieldId(name);
+          if (expectedId != currentId) {
+            return InstanceFieldIdMismatch(
+              libraryUri: libraryUri,
+              interfaceName: instanceName,
+              fieldName: name,
+              expectedId: expectedId,
+              actualId: currentId,
+            );
+          }
+        }
+
+        for (var methodEntry in requirements.requestedMethods.entries) {
+          var name = methodEntry.key;
           var expectedId = methodEntry.value;
-          if (expectedId != methodId) {
+          var currentId = instanceItem.getDeclaredMemberId(name);
+          if (expectedId != currentId) {
             return InstanceMethodIdMismatch(
               libraryUri: libraryUri,
               interfaceName: instanceName,
-              methodName: methodName,
+              methodName: name,
               expectedId: expectedId,
-              actualId: methodId,
+              actualId: currentId,
             );
           }
         }
@@ -529,6 +554,23 @@ class RequirementsManifest {
     // TODO(scheglov): implement.
   }
 
+  void record_instanceElement_getField({
+    required InstanceElementImpl2 element,
+    required String name,
+  }) {
+    var itemRequirements = _getInstanceItem(element);
+    if (itemRequirements == null) {
+      return;
+    }
+
+    var item = itemRequirements.item;
+    var requirements = itemRequirements.requirements;
+
+    var fieldName = name.asLookupName;
+    var fieldId = item.getDeclaredFieldId(fieldName);
+    requirements.requestedFields[fieldName] = fieldId;
+  }
+
   void record_instanceElement_getGetter({
     required InstanceElementImpl2 element,
     required String name,
@@ -560,6 +602,22 @@ class RequirementsManifest {
     record_instanceElement_getMethod(element: element, name: '$name=');
   }
 
+  void record_propertyAccessorElement_variable({
+    required PropertyAccessorElementImpl2 element,
+    required String? name,
+  }) {
+    if (name == null) {
+      return;
+    }
+
+    switch (element.enclosingElement2) {
+      case InstanceElementImpl2 instanceElement:
+        record_instanceElement_getField(element: instanceElement, name: name);
+      default:
+      // TODO(scheglov): support for top-level variables
+    }
+  }
+
   /// This method is invoked after linking of a library cycle, to exclude
   /// requirements to the libraries of this same library cycle. We already
   /// link these libraries together, so only requirements to the previous