Fine. Support for extensions.

Change-Id: I3ebae3c6228b1b2c95e224e2e6624e46212d3b2f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/430461
Reviewed-by: Brian Wilkerson <[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, ExtensionItem> declaredExtensions;
   final Map<LookupName, ExtensionTypeItem> declaredExtensionTypes;
   final Map<LookupName, MixinItem> declaredMixins;
   final Map<LookupName, TopLevelGetterItem> declaredGetters;
@@ -37,6 +38,7 @@ class LibraryManifest {
     required this.reExportMap,
     required this.declaredClasses,
     required this.declaredEnums,
+    required this.declaredExtensions,
     required this.declaredExtensionTypes,
     required this.declaredMixins,
     required this.declaredGetters,
@@ -54,6 +56,9 @@ class LibraryManifest {
       declaredEnums: reader.readLookupNameMap(
         readValue: () => EnumItem.read(reader),
       ),
+      declaredExtensions: reader.readLookupNameMap(
+        readValue: () => ExtensionItem.read(reader),
+      ),
       declaredExtensionTypes: reader.readLookupNameMap(
         readValue: () => ExtensionTypeItem.read(reader),
       ),
@@ -81,6 +86,7 @@ class LibraryManifest {
       ...<Map<LookupName, TopLevelItem>>[
             declaredClasses,
             declaredEnums,
+            declaredExtensions,
             declaredExtensionTypes,
             declaredMixins,
             declaredGetters,
@@ -98,6 +104,7 @@ class LibraryManifest {
   ManifestItemId? getExportedId(LookupName name) {
     return declaredClasses[name]?.id ??
         declaredEnums[name]?.id ??
+        declaredExtensions[name]?.id ??
         declaredExtensionTypes[name]?.id ??
         declaredMixins[name]?.id ??
         declaredGetters[name]?.id ??
@@ -110,6 +117,7 @@ class LibraryManifest {
     reExportMap.write(sink);
     declaredClasses.write(sink);
     declaredEnums.write(sink);
+    declaredExtensions.write(sink);
     declaredExtensionTypes.write(sink);
     declaredMixins.write(sink);
     declaredGetters.write(sink);
@@ -287,6 +295,33 @@ class LibraryManifestBuilder {
     });
   }
 
+  void _addExtension({
+    required EncodeContext encodingContext,
+    required Map<LookupName, ExtensionItem> newItems,
+    required ExtensionElementImpl2 element,
+    required LookupName lookupName,
+  }) {
+    var extensionItem = _getOrBuildElementItem(element, () {
+      return ExtensionItem.fromElement(
+        id: ManifestItemId.generate(),
+        context: encodingContext,
+        element: element,
+      );
+    });
+    newItems[lookupName] = extensionItem;
+
+    encodingContext.withTypeParameters(element.typeParameters2, (
+      typeParameters,
+    ) {
+      extensionItem.beforeUpdatingMembers();
+      _addInstanceElementMembers(
+        encodingContext: encodingContext,
+        instanceElement: element,
+        instanceItem: extensionItem,
+      );
+    });
+  }
+
   void _addExtensionType({
     required EncodeContext encodingContext,
     required Map<LookupName, TopLevelItem> newItems,
@@ -652,6 +687,7 @@ class LibraryManifestBuilder {
       var libraryUri = libraryElement.uri;
       var newClassItems = <LookupName, ClassItem>{};
       var newEnumItems = <LookupName, EnumItem>{};
+      var newExtensionItems = <LookupName, ExtensionItem>{};
       var newExtensionTypeItems = <LookupName, ExtensionTypeItem>{};
       var newMixinItems = <LookupName, MixinItem>{};
       var newTopLevelGetters = <LookupName, TopLevelGetterItem>{};
@@ -680,6 +716,13 @@ class LibraryManifestBuilder {
               element: element,
               lookupName: lookupName,
             );
+          case ExtensionElementImpl2():
+            _addExtension(
+              encodingContext: encodingContext,
+              newItems: newExtensionItems,
+              element: element,
+              lookupName: lookupName,
+            );
           case ExtensionTypeElementImpl2():
             _addExtensionType(
               encodingContext: encodingContext,
@@ -731,6 +774,7 @@ class LibraryManifestBuilder {
         reExportMap: {},
         declaredClasses: newClassItems,
         declaredEnums: newEnumItems,
+        declaredExtensions: newExtensionItems,
         declaredExtensionTypes: newExtensionTypeItems,
         declaredMixins: newMixinItems,
         declaredGetters: newTopLevelGetters,
@@ -909,6 +953,7 @@ class LibraryManifestBuilder {
           reExportMap: {},
           declaredClasses: {},
           declaredEnums: {},
+          declaredExtensions: {},
           declaredExtensionTypes: {},
           declaredMixins: {},
           declaredGetters: {},
@@ -1041,6 +1086,10 @@ class _LibraryMatch {
           if (!_matchEnum(name: name, element: element)) {
             structureMismatched.add(element);
           }
+        case ExtensionElementImpl2():
+          if (!_matchExtension(name: name, element: element)) {
+            structureMismatched.add(element);
+          }
         case ExtensionTypeElementImpl2():
           if (!_matchExtensionType(name: name, element: element)) {
             structureMismatched.add(element);
@@ -1144,6 +1193,31 @@ class _LibraryMatch {
     return true;
   }
 
+  bool _matchExtension({
+    required LookupName? name,
+    required ExtensionElementImpl2 element,
+  }) {
+    var item = manifest.declaredExtensions[name];
+    if (item == null) {
+      return false;
+    }
+
+    var matchContext = MatchContext(parent: null);
+    if (!item.match(matchContext, element)) {
+      return false;
+    }
+
+    _addMatchingElementItem(element, item, matchContext);
+
+    _matchInstanceElementExecutables(
+      matchContext: matchContext,
+      element: element,
+      item: item,
+    );
+
+    return true;
+  }
+
   bool _matchExtensionType({
     required LookupName? name,
     required ExtensionTypeElementImpl2 element,

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

@@ -144,6 +144,78 @@ class EnumItem extends InterfaceItem<EnumElementImpl2> {
   }
 }
 
+/// The item for [ExtensionElementImpl2].
+class ExtensionItem<E extends ExtensionElementImpl2> extends InstanceItem<E> {
+  final ManifestType extendedType;
+
+  ExtensionItem({
+    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 this.extendedType,
+  });
+
+  factory ExtensionItem.fromElement({
+    required ManifestItemId id,
+    required EncodeContext context,
+    required ExtensionElementImpl2 element,
+  }) {
+    return context.withTypeParameters(element.typeParameters2, (
+      typeParameters,
+    ) {
+      return ExtensionItem(
+        id: id,
+        metadata: ManifestMetadata.encode(context, element.metadata2),
+        typeParameters: typeParameters,
+        declaredConflicts: {},
+        declaredFields: {},
+        declaredGetters: {},
+        declaredSetters: {},
+        declaredMethods: {},
+        declaredConstructors: {},
+        inheritedConstructors: {},
+        extendedType: element.extendedType.encode(context),
+      );
+    });
+  }
+
+  factory ExtensionItem.read(SummaryDataReader reader) {
+    return ExtensionItem(
+      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(),
+      extendedType: ManifestType.read(reader),
+    );
+  }
+
+  @override
+  bool match(MatchContext context, E element) {
+    context.addTypeParameters(element.typeParameters2);
+    return super.match(context, element) &&
+        extendedType.match(context, element.extendedType);
+  }
+
+  @override
+  void write(BufferedSink sink) {
+    super.write(sink);
+    extendedType.write(sink);
+  }
+}
+
 class ExtensionTypeItem extends InterfaceItem<ExtensionTypeElementImpl2> {
   ExtensionTypeItem({
     required super.id,

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

@@ -423,6 +423,7 @@ class RequirementsManifest {
         var instanceItem =
             libraryManifest.declaredClasses[instanceName] ??
             libraryManifest.declaredEnums[instanceName] ??
+            libraryManifest.declaredExtensions[instanceName] ??
             libraryManifest.declaredExtensionTypes[instanceName] ??
             libraryManifest.declaredMixins[instanceName];
         if (instanceItem is! InstanceItem) {
@@ -889,6 +890,7 @@ class RequirementsManifest {
     var instanceItem =
         manifest.declaredClasses[instanceName] ??
         manifest.declaredEnums[instanceName] ??
+        manifest.declaredExtensions[instanceName] ??
         manifest.declaredExtensionTypes[instanceName] ??
         manifest.declaredMixins[instanceName];