Fine. Use single _matchInstanceElementExecutables(), for static and instance.

With the current implementation for building the interface, and merging
executables, we don't care about the distinction.

Also, separate individual _matchInstanceElementXyz, it seems more
direct to iterate over specific types, and not re-swtich by type.

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

Author: scheglov

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

@@ -856,147 +856,171 @@ class _LibraryMatch {
     _addMatchingElementItem(element, item, matchContext);
 
     _matchInterfaceElementConstructors(
-      matchContext: matchContext,
       interfaceElement: element,
       item: item,
-    );
-
-    _matchInstanceElementStaticExecutables(
       matchContext: matchContext,
-      element: element,
-      item: item,
     );
 
-    _matchInterfaceElementInstanceExecutables(
-      matchContext: matchContext,
+    _matchInstanceElementExecutables(
       element: element,
       item: item,
+      matchContext: matchContext,
     );
 
     return true;
   }
 
-  bool _matchInstanceElementExecutable({
-    required MatchContext interfaceMatchContext,
-    required Map<BaseName, BaseNameMembers> members,
-    required ExecutableElementImpl2 executable,
+  void _matchInstanceElementExecutables({
+    required InstanceElementImpl2 element,
+    required InstanceItem item,
+    required MatchContext matchContext,
   }) {
-    var lookupName = executable.lookupName?.asLookupName;
+    for (var field in element.fields2) {
+      if (!_matchInstanceElementField(
+        instanceItem: item,
+        instanceMatchContext: matchContext,
+        element: field,
+      )) {
+        structureMismatched.add(field);
+      }
+    }
+
+    for (var method in element.methods2) {
+      if (!_matchInstanceElementMethod(
+        instanceItem: item,
+        instanceMatchContext: matchContext,
+        element: method,
+      )) {
+        structureMismatched.add(method);
+      }
+    }
+
+    for (var getter in element.getters2) {
+      if (!_matchInstanceElementGetter(
+        instanceItem: item,
+        instanceMatchContext: matchContext,
+        element: getter,
+      )) {
+        structureMismatched.add(getter);
+      }
+    }
+
+    for (var setter in element.setters2) {
+      if (!_matchInstanceElementSetter(
+        instanceItem: item,
+        instanceMatchContext: matchContext,
+        element: setter,
+      )) {
+        structureMismatched.add(setter);
+      }
+    }
+  }
+
+  bool _matchInstanceElementField({
+    required InstanceItem instanceItem,
+    required MatchContext instanceMatchContext,
+    required FieldElementImpl2 element,
+  }) {
+    var lookupName = element.lookupName?.asLookupName;
     if (lookupName == null) {
       return true;
     }
-    var baseName = lookupName.asBaseName;
-
-    switch (executable) {
-      case GetterElementImpl():
-        var item = members[baseName]?.declaredGetter;
-        if (item is! InstanceItemGetterItem) {
-          return false;
-        }
 
-        var matchContext = MatchContext(parent: interfaceMatchContext);
-        if (!item.match(matchContext, executable)) {
-          return false;
-        }
+    var item = instanceItem.declaredFields[lookupName];
+    if (item == null) {
+      return false;
+    }
 
-        _addMatchingElementItem(executable, item, matchContext);
-        return true;
-      case MethodElementImpl2():
-        var item =
-            lookupName.isIndexEq
-                ? members[baseName]?.declaredIndexEq
-                : members[baseName]?.declaredMethod;
-        if (item is! InstanceItemMethodItem) {
-          return false;
-        }
+    var matchContext = MatchContext(parent: instanceMatchContext);
+    if (!item.match(matchContext, element)) {
+      return false;
+    }
 
-        var matchContext = MatchContext(parent: interfaceMatchContext);
-        if (!item.match(matchContext, executable)) {
-          return false;
-        }
+    _addMatchingElementItem(element, item, matchContext);
+    return true;
+  }
 
-        _addMatchingElementItem(executable, item, matchContext);
-        return true;
-      case SetterElementImpl():
-        var item = members[baseName]?.declaredSetter;
-        if (item is! InstanceItemSetterItem) {
-          return false;
-        }
+  bool _matchInstanceElementGetter({
+    required InstanceItem instanceItem,
+    required MatchContext instanceMatchContext,
+    required GetterElementImpl element,
+  }) {
+    var lookupName = element.lookupName?.asLookupName;
+    if (lookupName == null) {
+      return false;
+    }
 
-        var matchContext = MatchContext(parent: interfaceMatchContext);
-        if (!item.match(matchContext, executable)) {
-          return false;
-        }
+    var baseName = lookupName.asBaseName;
+    var item = instanceItem.declaredMembers[baseName]?.declaredGetter;
+    if (item is! InstanceItemGetterItem) {
+      return false;
+    }
 
-        _addMatchingElementItem(executable, item, matchContext);
-        return true;
-      default:
-        // SAFETY: the cases above handle all expected executables.
-        throw StateError('(${executable.runtimeType}) $executable');
+    var matchContext = MatchContext(parent: instanceMatchContext);
+    if (!item.match(matchContext, element)) {
+      return false;
     }
+
+    _addMatchingElementItem(element, item, matchContext);
+    return true;
   }
 
-  bool _matchInstanceElementField({
+  bool _matchInstanceElementMethod({
     required InstanceItem instanceItem,
     required MatchContext instanceMatchContext,
-    required FieldElementImpl2 field,
+    required MethodElementImpl2 element,
   }) {
-    var lookupName = field.lookupName?.asLookupName;
+    var lookupName = element.lookupName?.asLookupName;
     if (lookupName == null) {
-      return true;
+      return false;
     }
 
-    var item = instanceItem.declaredFields[lookupName];
-    if (item == null) {
+    var baseName = lookupName.asBaseName;
+    var item =
+        lookupName.isIndexEq
+            ? instanceItem.declaredMembers[baseName]?.declaredIndexEq
+            : instanceItem.declaredMembers[baseName]?.declaredMethod;
+    if (item is! InstanceItemMethodItem) {
       return false;
     }
 
     var matchContext = MatchContext(parent: instanceMatchContext);
-    if (!item.match(matchContext, field)) {
+    if (!item.match(matchContext, element)) {
       return false;
     }
 
-    _addMatchingElementItem(field, item, matchContext);
+    _addMatchingElementItem(element, item, matchContext);
     return true;
   }
 
-  void _matchInstanceElementStaticExecutables({
-    required MatchContext matchContext,
-    required InstanceElementImpl2 element,
-    required InstanceItem item,
+  bool _matchInstanceElementSetter({
+    required InstanceItem instanceItem,
+    required MatchContext instanceMatchContext,
+    required SetterElementImpl element,
   }) {
-    for (var field in element.fields2) {
-      if (!_matchInstanceElementField(
-        instanceItem: item,
-        instanceMatchContext: matchContext,
-        field: field,
-      )) {
-        structureMismatched.add(field);
-      }
+    var lookupName = element.lookupName?.asLookupName;
+    if (lookupName == null) {
+      return true;
     }
 
-    var executables = [
-      ...element.getters2,
-      ...element.methods2,
-      ...element.setters2,
-    ];
-
-    for (var executable in executables) {
-      if (executable.isStatic) {
-        if (!_matchInstanceElementExecutable(
-          interfaceMatchContext: matchContext,
-          members: item.declaredMembers,
-          executable: executable,
-        )) {
-          structureMismatched.add(executable);
-        }
-      }
+    var baseName = lookupName.asBaseName;
+    var item = instanceItem.declaredMembers[baseName]?.declaredSetter;
+    if (item is! InstanceItemSetterItem) {
+      return false;
+    }
+
+    var matchContext = MatchContext(parent: instanceMatchContext);
+    if (!item.match(matchContext, element)) {
+      return false;
     }
+
+    _addMatchingElementItem(element, item, matchContext);
+    return true;
   }
 
   bool _matchInterfaceElementConstructor({
+    required InterfaceItem interfaceItem,
     required MatchContext interfaceMatchContext,
-    required Map<BaseName, BaseNameMembers> members,
     required ConstructorElementImpl2 element,
   }) {
     var lookupName = element.lookupName?.asLookupName;
@@ -1005,7 +1029,7 @@ class _LibraryMatch {
     }
 
     var baseName = lookupName.asBaseName;
-    var item = members[baseName]?.declaredConstructor;
+    var item = interfaceItem.declaredMembers[baseName]?.declaredConstructor;
     if (item is! InterfaceItemConstructorItem) {
       return false;
     }
@@ -1026,36 +1050,15 @@ class _LibraryMatch {
   }) {
     for (var constructor in interfaceElement.constructors2) {
       if (!_matchInterfaceElementConstructor(
+        interfaceItem: item,
         interfaceMatchContext: matchContext,
-        members: item.declaredMembers,
         element: constructor,
       )) {
         structureMismatched.add(constructor);
       }
     }
   }
 
-  void _matchInterfaceElementInstanceExecutables({
-    required MatchContext matchContext,
-    required InterfaceElementImpl2 element,
-    required InterfaceItem item,
-  }) {
-    var map = element.inheritanceManager.getInterface2(element).map2;
-    for (var executable in map.values) {
-      if (executable.enclosingElement2 == element) {
-        // SAFETY: declared in the element are always impl.
-        executable as ExecutableElementImpl2;
-        if (!_matchInstanceElementExecutable(
-          interfaceMatchContext: matchContext,
-          members: item.declaredMembers,
-          executable: executable,
-        )) {
-          structureMismatched.add(executable);
-        }
-      }
-    }
-  }
-
   bool _matchMixin({
     required LookupName? name,
     required MixinElementImpl2 element,
@@ -1072,16 +1075,10 @@ class _LibraryMatch {
 
     _addMatchingElementItem(element, item, matchContext);
 
-    _matchInstanceElementStaticExecutables(
-      matchContext: matchContext,
+    _matchInstanceElementExecutables(
       element: element,
       item: item,
-    );
-
-    _matchInterfaceElementInstanceExecutables(
       matchContext: matchContext,
-      element: element,
-      item: item,
     );
 
     return true;