Fine. Rename InstanceItemMemberItem subclasses.

Previously InstanceMemberItem was confusing, because it could be read
as instance vs. static, when actually it is InstanceElementImpl member.

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

Author: scheglov

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

@@ -188,7 +188,7 @@ class LibraryManifestBuilder {
     required LookupName lookupName,
   }) {
     var item = _getOrBuildElementItem(element, () {
-      return InstanceGetterItem.fromElement(
+      return InstanceItemGetterItem.fromElement(
         name: lookupName,
         id: ManifestItemId.generate(),
         context: encodingContext,
@@ -205,7 +205,7 @@ class LibraryManifestBuilder {
     required LookupName lookupName,
   }) {
     var item = _getOrBuildElementItem(element, () {
-      return InstanceMethodItem.fromElement(
+      return InstanceItemMethodItem.fromElement(
         name: lookupName,
         id: ManifestItemId.generate(),
         context: encodingContext,
@@ -222,7 +222,7 @@ class LibraryManifestBuilder {
     required LookupName lookupName,
   }) {
     var item = _getOrBuildElementItem(element, () {
-      return InterfaceConstructorItem.fromElement(
+      return InterfaceItemConstructorItem.fromElement(
         name: lookupName,
         id: ManifestItemId.generate(),
         context: encodingContext,
@@ -649,15 +649,15 @@ class _LibraryMatch {
 
   bool _matchInstanceExecutable({
     required MatchContext interfaceMatchContext,
-    required Map<LookupName, InstanceMemberItem> members,
+    required Map<LookupName, InstanceItemMemberItem> members,
     required LookupName lookupName,
     required ExecutableElement2 executable,
   }) {
     var item = members[lookupName];
 
     switch (executable) {
       case GetterElement2OrMember():
-        if (item is! InstanceGetterItem) {
+        if (item is! InstanceItemGetterItem) {
           return false;
         }
 
@@ -671,7 +671,7 @@ class _LibraryMatch {
         refExternalIds.addAll(matchContext.externalIds);
         return true;
       case MethodElement2OrMember():
-        if (item is! InstanceMethodItem) {
+        if (item is! InstanceItemMethodItem) {
           return false;
         }
 
@@ -715,7 +715,7 @@ class _LibraryMatch {
 
   bool _matchInterfaceConstructor({
     required MatchContext interfaceMatchContext,
-    required Map<LookupName, InstanceMemberItem> members,
+    required Map<LookupName, InstanceItemMemberItem> members,
     required ConstructorElementImpl2 element,
   }) {
     var lookupName = element.name3?.asLookupName;
@@ -724,7 +724,7 @@ class _LibraryMatch {
     }
 
     var item = members[lookupName];
-    if (item is! InterfaceConstructorItem) {
+    if (item is! InterfaceItemConstructorItem) {
       return false;
     }
 

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

@@ -96,30 +96,65 @@ class ExportItem extends TopLevelItem {
   }
 }
 
-class InstanceGetterItem extends InstanceMemberItem {
+/// The item for [InstanceElementImpl2].
+sealed class InstanceItem extends TopLevelItem {
+  final List<ManifestTypeParameter> typeParameters;
+  final Map<LookupName, InstanceItemMemberItem> members;
+
+  InstanceItem({
+    required super.libraryUri,
+    required super.name,
+    required super.id,
+    required this.typeParameters,
+    required this.members,
+  });
+
+  void _write(BufferedSink sink) {
+    sink.writeUri(libraryUri);
+    name.write(sink);
+    id.write(sink);
+    typeParameters.writeList(sink);
+    sink.writeMap(
+      members,
+      writeKey: (name) => name.write(sink),
+      writeValue: (member) => member.write(sink),
+    );
+  }
+
+  static Map<LookupName, InstanceItemMemberItem> _readMembers(
+    SummaryDataReader reader,
+  ) {
+    return reader.readMap(
+      readKey: () => LookupName.read(reader),
+      readValue: () => InstanceItemMemberItem.read(reader),
+    );
+  }
+}
+
+class InstanceItemGetterItem extends InstanceItemMemberItem {
   final ManifestType returnType;
 
-  InstanceGetterItem({
+  InstanceItemGetterItem({
     required super.name,
     required super.id,
     required this.returnType,
   });
 
-  factory InstanceGetterItem.fromElement({
+  factory InstanceItemGetterItem.fromElement({
     required LookupName name,
     required ManifestItemId id,
     required EncodeContext context,
     required GetterElement2OrMember element,
   }) {
-    return InstanceGetterItem(
+    return InstanceItemGetterItem(
       name: name,
       id: id,
       returnType: element.returnType.encode(context),
     );
   }
 
-  factory InstanceGetterItem.read(SummaryDataReader reader) {
-    return InstanceGetterItem(
+  factory InstanceItemGetterItem.read(SummaryDataReader reader) {
+    return InstanceItemGetterItem(
       name: LookupName.read(reader),
       id: ManifestItemId.read(reader),
       returnType: ManifestType.read(reader),
@@ -146,87 +181,52 @@ class InstanceGetterItem extends InstanceMemberItem {
   }
 }
 
-/// The item for [InstanceElementImpl2].
-sealed class InstanceItem extends TopLevelItem {
-  final List<ManifestTypeParameter> typeParameters;
-  final Map<LookupName, InstanceMemberItem> members;
-
-  InstanceItem({
-    required super.libraryUri,
-    required super.name,
-    required super.id,
-    required this.typeParameters,
-    required this.members,
-  });
-
-  void _write(BufferedSink sink) {
-    sink.writeUri(libraryUri);
-    name.write(sink);
-    id.write(sink);
-    typeParameters.writeList(sink);
-    sink.writeMap(
-      members,
-      writeKey: (name) => name.write(sink),
-      writeValue: (member) => member.write(sink),
-    );
-  }
-
-  static Map<LookupName, InstanceMemberItem> _readMembers(
-    SummaryDataReader reader,
-  ) {
-    return reader.readMap(
-      readKey: () => LookupName.read(reader),
-      readValue: () => InstanceMemberItem.read(reader),
-    );
-  }
-}
-
-sealed class InstanceMemberItem extends ManifestItem {
+sealed class InstanceItemMemberItem extends ManifestItem {
   final LookupName name;
   final ManifestItemId id;
 
-  InstanceMemberItem({
+  InstanceItemMemberItem({
     required this.name,
     required this.id,
   });
 
-  factory InstanceMemberItem.read(SummaryDataReader reader) {
+  factory InstanceItemMemberItem.read(SummaryDataReader reader) {
     var kind = reader.readEnum(_ManifestItemKind2.values);
     switch (kind) {
       case _ManifestItemKind2.instanceGetter:
-        return InstanceGetterItem.read(reader);
+        return InstanceItemGetterItem.read(reader);
       case _ManifestItemKind2.instanceMethod:
-        return InstanceMethodItem.read(reader);
+        return InstanceItemMethodItem.read(reader);
       case _ManifestItemKind2.interfaceConstructor:
-        return InterfaceConstructorItem.read(reader);
+        return InterfaceItemConstructorItem.read(reader);
     }
   }
 }
 
-class InstanceMethodItem extends InstanceMemberItem {
+class InstanceItemMethodItem extends InstanceItemMemberItem {
   final ManifestFunctionType functionType;
 
-  InstanceMethodItem({
+  InstanceItemMethodItem({
     required super.name,
     required super.id,
     required this.functionType,
   });
 
-  factory InstanceMethodItem.fromElement({
+  factory InstanceItemMethodItem.fromElement({
     required LookupName name,
     required ManifestItemId id,
     required EncodeContext context,
     required MethodElement2OrMember element,
   }) {
-    return InstanceMethodItem(
+    return InstanceItemMethodItem(
       name: name,
       id: id,
       functionType: element.type.encode(context),
     );
   }
 
-  factory InstanceMethodItem.read(SummaryDataReader reader) {
-    return InstanceMethodItem(
+  factory InstanceItemMethodItem.read(SummaryDataReader reader) {
+    return InstanceItemMethodItem(
       name: LookupName.read(reader),
       id: ManifestItemId.read(reader),
       functionType: ManifestFunctionType.read(reader),
@@ -253,27 +253,64 @@ class InstanceMethodItem extends InstanceMemberItem {
   }
 }
 
-class InterfaceConstructorItem extends InstanceMemberItem {
+/// The item for [InterfaceElementImpl2].
+sealed class InterfaceItem extends InstanceItem {
+  final ManifestType? supertype;
+  final List<ManifestType> interfaces;
+  final List<ManifestType> mixins;
+
+  InterfaceItem({
+    required super.libraryUri,
+    required super.name,
+    required super.id,
+    required super.typeParameters,
+    required super.members,
+    required this.supertype,
+    required this.interfaces,
+    required this.mixins,
+  });
+
+  MatchContext? _matchInterfaceElement(InterfaceElementImpl2 element) {
+    var context = MatchContext(parent: null);
+    context.addTypeParameters(element.typeParameters2);
+    if (supertype.match(context, element.supertype) &&
+        interfaces.match(context, element.interfaces) &&
+        mixins.match(context, element.mixins)) {
+      return context;
+    }
+    return null;
+  }
+
+  @override
+  void _write(BufferedSink sink) {
+    super._write(sink);
+    supertype.writeOptional(sink);
+    mixins.writeList(sink);
+    interfaces.writeList(sink);
+  }
+}
+
+class InterfaceItemConstructorItem extends InstanceItemMemberItem {
   final bool isConst;
   final bool isFactory;
   final ManifestFunctionType functionType;
 
-  InterfaceConstructorItem({
+  InterfaceItemConstructorItem({
     required super.name,
     required super.id,
     required this.isConst,
     required this.isFactory,
     required this.functionType,
   });
 
-  factory InterfaceConstructorItem.fromElement({
+  factory InterfaceItemConstructorItem.fromElement({
     required LookupName name,
     required ManifestItemId id,
     required EncodeContext context,
     required ConstructorElementImpl2 element,
   }) {
     // TODO(scheglov): initializers
-    return InterfaceConstructorItem(
+    return InterfaceItemConstructorItem(
       name: name,
       id: id,
       isConst: element.isConst,
@@ -282,8 +319,8 @@ class InterfaceConstructorItem extends InstanceMemberItem {
     );
   }
 
-  factory InterfaceConstructorItem.read(SummaryDataReader reader) {
-    return InterfaceConstructorItem(
+  factory InterfaceItemConstructorItem.read(SummaryDataReader reader) {
+    return InterfaceItemConstructorItem(
       name: LookupName.read(reader),
       id: ManifestItemId.read(reader),
       isConst: reader.readBool(),
@@ -320,43 +357,6 @@ class InterfaceConstructorItem extends InstanceMemberItem {
   }
 }
 
-/// The item for [InterfaceElementImpl2].
-sealed class InterfaceItem extends InstanceItem {
-  final ManifestType? supertype;
-  final List<ManifestType> interfaces;
-  final List<ManifestType> mixins;
-
-  InterfaceItem({
-    required super.libraryUri,
-    required super.name,
-    required super.id,
-    required super.typeParameters,
-    required super.members,
-    required this.supertype,
-    required this.interfaces,
-    required this.mixins,
-  });
-
-  MatchContext? _matchInterfaceElement(InterfaceElementImpl2 element) {
-    var context = MatchContext(parent: null);
-    context.addTypeParameters(element.typeParameters2);
-    if (supertype.match(context, element.supertype) &&
-        interfaces.match(context, element.interfaces) &&
-        mixins.match(context, element.mixins)) {
-      return context;
-    }
-    return null;
-  }
-
-  @override
-  void _write(BufferedSink sink) {
-    super._write(sink);
-    supertype.writeOptional(sink);
-    mixins.writeList(sink);
-    interfaces.writeList(sink);
-  }
-}
-
 class ManifestAnnotation {
   final ManifestNode ast;