Fine. Support for extension types.

Change-Id: I82bcaafd877b1192806343ea46e2c6a5594f131a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/430520
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

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

@@ -26,6 +26,7 @@ class LibraryManifest {
 
   final Map<LookupName, ClassItem> declaredClasses;
   final Map<LookupName, EnumItem> declaredEnums;
+  final Map<LookupName, ExtensionTypeItem> declaredExtensionTypes;
   final Map<LookupName, MixinItem> declaredMixins;
   final Map<LookupName, TopLevelGetterItem> declaredGetters;
   final Map<LookupName, TopLevelSetterItem> declaredSetters;
@@ -36,6 +37,7 @@ class LibraryManifest {
     required this.reExportMap,
     required this.declaredClasses,
     required this.declaredEnums,
+    required this.declaredExtensionTypes,
     required this.declaredMixins,
     required this.declaredGetters,
     required this.declaredSetters,
@@ -52,6 +54,9 @@ class LibraryManifest {
       declaredEnums: reader.readLookupNameMap(
         readValue: () => EnumItem.read(reader),
       ),
+      declaredExtensionTypes: reader.readLookupNameMap(
+        readValue: () => ExtensionTypeItem.read(reader),
+      ),
       declaredMixins: reader.readLookupNameMap(
         readValue: () => MixinItem.read(reader),
       ),
@@ -76,6 +81,7 @@ class LibraryManifest {
       ...<Map<LookupName, TopLevelItem>>[
             declaredClasses,
             declaredEnums,
+            declaredExtensionTypes,
             declaredMixins,
             declaredGetters,
             declaredSetters,
@@ -92,6 +98,7 @@ class LibraryManifest {
   ManifestItemId? getExportedId(LookupName name) {
     return declaredClasses[name]?.id ??
         declaredEnums[name]?.id ??
+        declaredExtensionTypes[name]?.id ??
         declaredMixins[name]?.id ??
         declaredGetters[name]?.id ??
         declaredSetters[name]?.id ??
@@ -103,6 +110,7 @@ class LibraryManifest {
     reExportMap.write(sink);
     declaredClasses.write(sink);
     declaredEnums.write(sink);
+    declaredExtensionTypes.write(sink);
     declaredMixins.write(sink);
     declaredGetters.write(sink);
     declaredSetters.write(sink);
@@ -279,6 +287,33 @@ class LibraryManifestBuilder {
     });
   }
 
+  void _addExtensionType({
+    required EncodeContext encodingContext,
+    required Map<LookupName, TopLevelItem> newItems,
+    required ExtensionTypeElementImpl2 element,
+    required LookupName lookupName,
+  }) {
+    var extensionTypeItem = _getOrBuildElementItem(element, () {
+      return ExtensionTypeItem.fromElement(
+        id: ManifestItemId.generate(),
+        context: encodingContext,
+        element: element,
+      );
+    });
+    newItems[lookupName] = extensionTypeItem;
+
+    encodingContext.withTypeParameters(element.typeParameters2, (
+      typeParameters,
+    ) {
+      extensionTypeItem.beforeUpdatingMembers();
+      _addInterfaceElementMembers(
+        encodingContext: encodingContext,
+        instanceElement: element,
+        interfaceItem: extensionTypeItem,
+      );
+    });
+  }
+
   void _addInstanceElementField({
     required EncodeContext encodingContext,
     required InstanceItem instanceItem,
@@ -617,6 +652,7 @@ class LibraryManifestBuilder {
       var libraryUri = libraryElement.uri;
       var newClassItems = <LookupName, ClassItem>{};
       var newEnumItems = <LookupName, EnumItem>{};
+      var newExtensionTypeItems = <LookupName, ExtensionTypeItem>{};
       var newMixinItems = <LookupName, MixinItem>{};
       var newTopLevelGetters = <LookupName, TopLevelGetterItem>{};
       var newTopLevelSetters = <LookupName, TopLevelSetterItem>{};
@@ -644,6 +680,13 @@ class LibraryManifestBuilder {
               element: element,
               lookupName: lookupName,
             );
+          case ExtensionTypeElementImpl2():
+            _addExtensionType(
+              encodingContext: encodingContext,
+              newItems: newExtensionTypeItems,
+              element: element,
+              lookupName: lookupName,
+            );
           case GetterElementImpl():
             _addTopLevelGetter(
               encodingContext: encodingContext,
@@ -688,6 +731,7 @@ class LibraryManifestBuilder {
         reExportMap: {},
         declaredClasses: newClassItems,
         declaredEnums: newEnumItems,
+        declaredExtensionTypes: newExtensionTypeItems,
         declaredMixins: newMixinItems,
         declaredGetters: newTopLevelGetters,
         declaredSetters: newTopLevelSetters,
@@ -865,6 +909,7 @@ class LibraryManifestBuilder {
           reExportMap: {},
           declaredClasses: {},
           declaredEnums: {},
+          declaredExtensionTypes: {},
           declaredMixins: {},
           declaredGetters: {},
           declaredSetters: {},
@@ -996,6 +1041,10 @@ class _LibraryMatch {
           if (!_matchEnum(name: name, element: element)) {
             structureMismatched.add(element);
           }
+        case ExtensionTypeElementImpl2():
+          if (!_matchExtensionType(name: name, element: element)) {
+            structureMismatched.add(element);
+          }
         case GetterElementImpl():
           if (!_matchTopGetter(name: name, element: element)) {
             structureMismatched.add(element);
@@ -1095,6 +1144,37 @@ class _LibraryMatch {
     return true;
   }
 
+  bool _matchExtensionType({
+    required LookupName? name,
+    required ExtensionTypeElementImpl2 element,
+  }) {
+    var item = manifest.declaredExtensionTypes[name];
+    if (item is! ExtensionTypeItem) {
+      return false;
+    }
+
+    var matchContext = MatchContext(parent: null);
+    if (!item.match(matchContext, element)) {
+      return false;
+    }
+
+    _addMatchingElementItem(element, item, matchContext);
+
+    _matchInterfaceElementConstructors(
+      matchContext: matchContext,
+      interfaceElement: element,
+      item: item,
+    );
+
+    _matchInstanceElementExecutables(
+      matchContext: matchContext,
+      element: element,
+      item: item,
+    );
+
+    return true;
+  }
+
   void _matchInstanceElementExecutables({
     required InstanceElementImpl2 element,
     required InstanceItem item,

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

@@ -207,6 +207,7 @@ final class ManifestElement {
 enum ManifestElementKind {
   class_,
   enum_,
+  extensionType,
   mixin_,
   topLevelVariable,
   topLevelGetter,
@@ -224,6 +225,8 @@ enum ManifestElementKind {
         return ManifestElementKind.class_;
       case EnumElement():
         return ManifestElementKind.enum_;
+      case ExtensionTypeElement():
+        return ManifestElementKind.extensionType;
       case MixinElement():
         return ManifestElementKind.mixin_;
       case TopLevelVariableElement():

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

@@ -144,6 +144,71 @@ class EnumItem extends InterfaceItem<EnumElementImpl2> {
   }
 }
 
+class ExtensionTypeItem extends InterfaceItem<ExtensionTypeElementImpl2> {
+  ExtensionTypeItem({
+    required super.id,
+    required super.metadata,
+    required super.typeParameters,
+    required super.declaredConflicts,
+    required super.declaredFields,
+    required super.declaredGetters,
+    required super.declaredSetters,
+    required super.declaredMethods,
+    required super.declaredConstructors,
+    required super.inheritedConstructors,
+    required super.interface,
+    required super.supertype,
+    required super.mixins,
+    required super.interfaces,
+  });
+
+  factory ExtensionTypeItem.fromElement({
+    required ManifestItemId id,
+    required EncodeContext context,
+    required ExtensionTypeElementImpl2 element,
+  }) {
+    return context.withTypeParameters(element.typeParameters2, (
+      typeParameters,
+    ) {
+      return ExtensionTypeItem(
+        id: id,
+        metadata: ManifestMetadata.encode(context, element.metadata2),
+        typeParameters: typeParameters,
+        declaredConflicts: {},
+        declaredFields: {},
+        declaredGetters: {},
+        declaredSetters: {},
+        declaredMethods: {},
+        declaredConstructors: {},
+        inheritedConstructors: {},
+        interface: ManifestInterface.empty(),
+        supertype: element.supertype?.encode(context),
+        mixins: element.mixins.encode(context),
+        interfaces: element.interfaces.encode(context),
+      );
+    });
+  }
+
+  factory ExtensionTypeItem.read(SummaryDataReader reader) {
+    return ExtensionTypeItem(
+      id: ManifestItemId.read(reader),
+      metadata: ManifestMetadata.read(reader),
+      typeParameters: ManifestTypeParameter.readList(reader),
+      declaredConflicts: reader.readLookupNameToIdMap(),
+      declaredFields: InstanceItemFieldItem.readMap(reader),
+      declaredGetters: InstanceItemGetterItem.readMap(reader),
+      declaredSetters: InstanceItemSetterItem.readMap(reader),
+      declaredMethods: InstanceItemMethodItem.readMap(reader),
+      declaredConstructors: InterfaceItemConstructorItem.readMap(reader),
+      inheritedConstructors: reader.readLookupNameToIdMap(),
+      supertype: ManifestType.readOptional(reader),
+      mixins: ManifestType.readList(reader),
+      interfaces: ManifestType.readList(reader),
+      interface: ManifestInterface.read(reader),
+    );
+  }
+}
+
 /// The item for [InstanceElementImpl2].
 sealed class InstanceItem<E extends InstanceElementImpl2>
     extends TopLevelItem<E> {

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

@@ -423,6 +423,7 @@ class RequirementsManifest {
         var instanceItem =
             libraryManifest.declaredClasses[instanceName] ??
             libraryManifest.declaredEnums[instanceName] ??
+            libraryManifest.declaredExtensionTypes[instanceName] ??
             libraryManifest.declaredMixins[instanceName];
         if (instanceItem is! InstanceItem) {
           return TopLevelNotInterface(
@@ -507,6 +508,7 @@ class RequirementsManifest {
         var interfaceItem =
             libraryManifest.declaredClasses[interfaceName] ??
             libraryManifest.declaredEnums[interfaceName] ??
+            libraryManifest.declaredExtensionTypes[interfaceName] ??
             libraryManifest.declaredMixins[interfaceName];
         if (interfaceItem is! InterfaceItem) {
           return TopLevelNotInterface(
@@ -887,6 +889,7 @@ class RequirementsManifest {
     var instanceItem =
         manifest.declaredClasses[instanceName] ??
         manifest.declaredEnums[instanceName] ??
+        manifest.declaredExtensionTypes[instanceName] ??
         manifest.declaredMixins[instanceName];
 
     // SAFETY: every instance element must be in the manifest.
@@ -919,6 +922,7 @@ class RequirementsManifest {
     var interfaceItem =
         manifest.declaredClasses[interfaceName] ??
         manifest.declaredEnums[interfaceName] ??
+        manifest.declaredExtensionTypes[interfaceName] ??
         manifest.declaredMixins[interfaceName];
 
     // SAFETY: every interface element must be in the manifest.