Fine. Record and check allDeclaredConstructors for InterfaceElement(s).

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

Author: scheglov

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

@@ -4739,6 +4739,9 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
 
   @override
   List<ConstructorElementImpl> get constructors {
+    globalResultRequirements?.record_instanceElement_constructors(
+      element: this,
+    );
     ensureReadMembers();
     if (!identical(_constructors, _Sentinel.constructorElement)) {
       return _constructors;
@@ -4877,7 +4880,16 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
       element: this,
       name: name,
     );
-    return constructors.firstWhereOrNull((e) => e.name == name);
+
+    return globalResultRequirements.withoutRecording(
+      reason: r'''
+The result depends only on the requested constructor, which we have already
+recorded above.
+''',
+      operation: () {
+        return constructors.firstWhereOrNull((e) => e.name == name);
+      },
+    );
   }
 
   @Deprecated('Use getNamedConstructor instead')

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

@@ -138,6 +138,30 @@ class InstanceMethodIdMismatch extends RequirementFailure {
   }
 }
 
+class InterfaceChildrenIdsMismatch extends RequirementFailure {
+  final Uri libraryUri;
+  final LookupName interfaceName;
+  final String childrenPropertyName;
+  final ManifestItemIdList expectedIds;
+  final ManifestItemIdList actualIds;
+
+  InterfaceChildrenIdsMismatch({
+    required this.libraryUri,
+    required this.interfaceName,
+    required this.childrenPropertyName,
+    required this.expectedIds,
+    required this.actualIds,
+  });
+
+  @override
+  String toString() {
+    return 'InterfaceChildrenIdsMismatch(libraryUri: $libraryUri, '
+        'interfaceName: ${interfaceName.asString}, '
+        'childrenPropertyName: $childrenPropertyName, '
+        'expectedIds: $expectedIds, actualIds: $actualIds)';
+  }
+}
+
 class InterfaceConstructorIdMismatch extends RequirementFailure {
   final Uri libraryUri;
   final LookupName interfaceName;

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

@@ -260,36 +260,44 @@ class InterfaceItemRequirements {
   /// If the element was asked for its full interface.
   ManifestItemId? interfaceId;
 
-  final Map<LookupName, ManifestItemId?> constructors;
+  /// Set if [InstanceElementImpl.constructors] is invoked.
+  ManifestItemIdList? allDeclaredConstructors;
+
+  /// Requested with [InstanceElementImpl.getNamedConstructor].
+  final Map<LookupName, ManifestItemId?> requestedConstructors;
 
   /// These are "methods" in wide meaning: methods, getters, setters.
   final Map<LookupName, ManifestItemId?> methods;
 
   InterfaceItemRequirements({
     required this.interfaceId,
-    required this.constructors,
+    required this.allDeclaredConstructors,
+    required this.requestedConstructors,
     required this.methods,
   });
 
   factory InterfaceItemRequirements.empty() {
     return InterfaceItemRequirements(
       interfaceId: null,
-      constructors: {},
+      allDeclaredConstructors: null,
+      requestedConstructors: {},
       methods: {},
     );
   }
 
   factory InterfaceItemRequirements.read(SummaryDataReader reader) {
     return InterfaceItemRequirements(
       interfaceId: ManifestItemId.readOptional(reader),
-      constructors: reader.readNameToIdMap(),
+      allDeclaredConstructors: ManifestItemIdList.readOptional(reader),
+      requestedConstructors: reader.readNameToIdMap(),
       methods: reader.readNameToIdMap(),
     );
   }
 
   void write(BufferedSink sink) {
     interfaceId.writeOptional(sink);
-    sink.writeNameToIdMap(constructors);
+    allDeclaredConstructors.writeOptional(sink);
+    sink.writeNameToIdMap(requestedConstructors);
     sink.writeNameToIdMap(methods);
   }
 }
@@ -601,8 +609,8 @@ class RequirementsManifest {
           );
         }
 
-        var interfaceRequirements = interfaceEntry.value;
-        if (interfaceRequirements.interfaceId case var expectedId?) {
+        var requirements = interfaceEntry.value;
+        if (requirements.interfaceId case var expectedId?) {
           var actualId = interfaceItem.interface.id;
           if (expectedId != actualId) {
             return InterfaceIdMismatch(
@@ -614,7 +622,21 @@ class RequirementsManifest {
           }
         }
 
-        var constructors = interfaceRequirements.constructors;
+        if (requirements.allDeclaredConstructors case var required?) {
+          var actualItems = interfaceItem.declaredConstructors.values;
+          var actualIds = actualItems.map((item) => item.id);
+          if (!required.equalToIterable(actualIds)) {
+            return InterfaceChildrenIdsMismatch(
+              libraryUri: libraryUri,
+              interfaceName: interfaceName,
+              childrenPropertyName: 'constructors',
+              expectedIds: required,
+              actualIds: ManifestItemIdList(actualIds.toList()),
+            );
+          }
+        }
+
+        var constructors = requirements.requestedConstructors;
         for (var constructorEntry in constructors.entries) {
           var constructorName = constructorEntry.key;
           var constructorId = interfaceItem.getConstructorId(constructorName);
@@ -630,7 +652,7 @@ class RequirementsManifest {
           }
         }
 
-        var methods = interfaceRequirements.methods;
+        var methods = requirements.methods;
         for (var methodEntry in methods.entries) {
           var methodName = methodEntry.key;
           var methodId = interfaceItem.getInterfaceMethodId(methodName);
@@ -694,6 +716,26 @@ class RequirementsManifest {
     }
   }
 
+  void record_instanceElement_constructors({
+    required InterfaceElementImpl element,
+  }) {
+    if (_recordingLockLevel != 0) {
+      return;
+    }
+
+    var itemRequirements = _getInterfaceItem(element);
+    if (itemRequirements == null) {
+      return;
+    }
+
+    var item = itemRequirements.item;
+    var requirements = itemRequirements.requirements;
+
+    requirements.allDeclaredConstructors ??= ManifestItemIdList(
+      item.declaredConstructors.values.map((item) => item.id).toList(),
+    );
+  }
+
   void record_instanceElement_fields({required InstanceElementImpl element}) {
     if (_recordingLockLevel != 0) {
       return;
@@ -897,7 +939,7 @@ class RequirementsManifest {
 
     var constructorName = name.asLookupName;
     var constructorId = item.getConstructorId(constructorName);
-    requirements.constructors[constructorName] = constructorId;
+    requirements.requestedConstructors[constructorName] = constructorId;
   }
 
   void record_propertyAccessorElement_variable({