Fine. Support for type aliases.

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

Author: scheglov

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

@@ -9675,7 +9675,7 @@ class TypeAliasElementImpl2 extends TypeDefiningElementImpl2
         FragmentedAnnotatableElementMixin<TypeAliasFragment>,
         FragmentedElementMixin<TypeAliasFragment>,
         _HasSinceSdkVersionMixin
-    implements TypeAliasElement {
+    implements AnnotatableElementImpl, TypeAliasElement {
   @override
   final Reference reference;
 

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

@@ -29,6 +29,7 @@ class LibraryManifest {
   final Map<LookupName, ExtensionItem> declaredExtensions;
   final Map<LookupName, ExtensionTypeItem> declaredExtensionTypes;
   final Map<LookupName, MixinItem> declaredMixins;
+  final Map<LookupName, TypeAliasItem> declaredTypeAliases;
   final Map<LookupName, TopLevelGetterItem> declaredGetters;
   final Map<LookupName, TopLevelSetterItem> declaredSetters;
   final Map<LookupName, TopLevelFunctionItem> declaredFunctions;
@@ -41,6 +42,7 @@ class LibraryManifest {
     required this.declaredExtensions,
     required this.declaredExtensionTypes,
     required this.declaredMixins,
+    required this.declaredTypeAliases,
     required this.declaredGetters,
     required this.declaredSetters,
     required this.declaredFunctions,
@@ -65,6 +67,9 @@ class LibraryManifest {
       declaredMixins: reader.readLookupNameMap(
         readValue: () => MixinItem.read(reader),
       ),
+      declaredTypeAliases: reader.readLookupNameMap(
+        readValue: () => TypeAliasItem.read(reader),
+      ),
       declaredGetters: reader.readLookupNameMap(
         readValue: () => TopLevelGetterItem.read(reader),
       ),
@@ -89,6 +94,7 @@ class LibraryManifest {
             declaredExtensions,
             declaredExtensionTypes,
             declaredMixins,
+            declaredTypeAliases,
             declaredGetters,
             declaredSetters,
             declaredFunctions,
@@ -107,6 +113,7 @@ class LibraryManifest {
         declaredExtensions[name]?.id ??
         declaredExtensionTypes[name]?.id ??
         declaredMixins[name]?.id ??
+        declaredTypeAliases[name]?.id ??
         declaredGetters[name]?.id ??
         declaredSetters[name]?.id ??
         declaredFunctions[name]?.id ??
@@ -120,6 +127,7 @@ class LibraryManifest {
     declaredExtensions.write(sink);
     declaredExtensionTypes.write(sink);
     declaredMixins.write(sink);
+    declaredTypeAliases.write(sink);
     declaredGetters.write(sink);
     declaredSetters.write(sink);
     declaredFunctions.write(sink);
@@ -654,6 +662,22 @@ class LibraryManifestBuilder {
     newItems[lookupName] = item;
   }
 
+  void _addTypeAlias({
+    required EncodeContext encodingContext,
+    required Map<LookupName, TypeAliasItem> newItems,
+    required TypeAliasElementImpl2 element,
+    required LookupName lookupName,
+  }) {
+    var item = _getOrBuildElementItem(element, () {
+      return TypeAliasItem.fromElement(
+        id: ManifestItemId.generate(),
+        context: encodingContext,
+        element: element,
+      );
+    });
+    newItems[lookupName] = item;
+  }
+
   /// Assert that every manifest can be serialized, and when deserialized
   /// results in the same manifest.
   bool _assertSerialization() {
@@ -690,6 +714,7 @@ class LibraryManifestBuilder {
       var newExtensionItems = <LookupName, ExtensionItem>{};
       var newExtensionTypeItems = <LookupName, ExtensionTypeItem>{};
       var newMixinItems = <LookupName, MixinItem>{};
+      var newTypeAliasItems = <LookupName, TypeAliasItem>{};
       var newTopLevelGetters = <LookupName, TopLevelGetterItem>{};
       var newTopLevelSetters = <LookupName, TopLevelSetterItem>{};
       var newTopLevelFunctions = <LookupName, TopLevelFunctionItem>{};
@@ -765,8 +790,13 @@ class LibraryManifestBuilder {
               element: element,
               lookupName: lookupName,
             );
-
-          // TODO(scheglov): add remaining elements
+          case TypeAliasElementImpl2():
+            _addTypeAlias(
+              encodingContext: encodingContext,
+              newItems: newTypeAliasItems,
+              element: element,
+              lookupName: lookupName,
+            );
         }
       }
 
@@ -777,6 +807,7 @@ class LibraryManifestBuilder {
         declaredExtensions: newExtensionItems,
         declaredExtensionTypes: newExtensionTypeItems,
         declaredMixins: newMixinItems,
+        declaredTypeAliases: newTypeAliasItems,
         declaredGetters: newTopLevelGetters,
         declaredSetters: newTopLevelSetters,
         declaredFunctions: newTopLevelFunctions,
@@ -956,6 +987,7 @@ class LibraryManifestBuilder {
           declaredExtensions: {},
           declaredExtensionTypes: {},
           declaredMixins: {},
+          declaredTypeAliases: {},
           declaredGetters: {},
           declaredSetters: {},
           declaredFunctions: {},
@@ -1114,6 +1146,10 @@ class _LibraryMatch {
           if (!_matchTopVariable(name: name, element: element)) {
             structureMismatched.add(element);
           }
+        case TypeAliasElementImpl2():
+          if (!_matchTypeAlias(name: name, element: element)) {
+            structureMismatched.add(element);
+          }
       }
     }
   }
@@ -1527,4 +1563,23 @@ class _LibraryMatch {
     _addMatchingElementItem(element, item, matchContext);
     return true;
   }
+
+  bool _matchTypeAlias({
+    required LookupName? name,
+    required TypeAliasElementImpl2 element,
+  }) {
+    var item = manifest.declaredTypeAliases[name];
+    if (item == null) {
+      return false;
+    }
+
+    var matchContext = MatchContext(parent: null);
+    if (!item.match(matchContext, element)) {
+      return false;
+    }
+
+    _addMatchingElementItem(element, item, matchContext);
+
+    return true;
+  }
 }

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

@@ -209,6 +209,7 @@ enum ManifestElementKind {
   enum_,
   extensionType,
   mixin_,
+  typeAlias,
   topLevelVariable,
   topLevelGetter,
   topLevelSetter,
@@ -249,6 +250,8 @@ enum ManifestElementKind {
         return ManifestElementKind.instanceMethod;
       case ConstructorElement():
         return ManifestElementKind.interfaceConstructor;
+      case TypeAliasElement():
+        return ManifestElementKind.typeAlias;
       default:
         throw StateError('Unexpected (${element.runtimeType}) $element');
     }

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

@@ -1368,6 +1368,58 @@ class TopLevelVariableItem extends TopLevelItem<TopLevelVariableElementImpl2> {
   }
 }
 
+class TypeAliasItem extends TopLevelItem<TypeAliasElementImpl2> {
+  final List<ManifestTypeParameter> typeParameters;
+  final ManifestType aliasedType;
+
+  TypeAliasItem({
+    required super.id,
+    required super.metadata,
+    required this.typeParameters,
+    required this.aliasedType,
+  });
+
+  factory TypeAliasItem.fromElement({
+    required ManifestItemId id,
+    required EncodeContext context,
+    required TypeAliasElementImpl2 element,
+  }) {
+    return context.withTypeParameters(element.typeParameters2, (
+      typeParameters,
+    ) {
+      return TypeAliasItem(
+        id: id,
+        metadata: ManifestMetadata.encode(context, element.metadata2),
+        typeParameters: typeParameters,
+        aliasedType: element.aliasedType.encode(context),
+      );
+    });
+  }
+
+  factory TypeAliasItem.read(SummaryDataReader reader) {
+    return TypeAliasItem(
+      id: ManifestItemId.read(reader),
+      metadata: ManifestMetadata.read(reader),
+      typeParameters: ManifestTypeParameter.readList(reader),
+      aliasedType: ManifestType.read(reader),
+    );
+  }
+
+  @override
+  bool match(MatchContext context, TypeAliasElementImpl2 element) {
+    context.addTypeParameters(element.typeParameters2);
+    return super.match(context, element) &&
+        aliasedType.match(context, element.aliasedType);
+  }
+
+  @override
+  void write(BufferedSink sink) {
+    super.write(sink);
+    typeParameters.writeList(sink);
+    aliasedType.write(sink);
+  }
+}
+
 enum _InstanceItemMemberItemKind { field, constructor, method, getter, setter }
 
 extension LookupNameToIdMapExtension on Map<LookupName, ManifestItemId> {