Serialize constant instance creation of generic classes.

pkg/analyzer/lib/src/summary/summarize_elements.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 660 matching lines @@
     if (typeParameter.bound != null) {
       b.bound = serializeTypeRef(typeParameter.bound, typeParameter);
     }
     return b;
   }
 
   /**
    * Serialize the given [type] into a [EntityRef].  If [slot] is provided,
    * it should be included in the [EntityRef].  If [linked] is true, any
    * references that are created will be populated into [linkedReferences] but
-   * [not [unlinkedReferences].
+   * not [unlinkedReferences].
    *
    * [context] is the element within which the [EntityRef] will be
    * interpreted; this is used to serialize type parameters.
    */
   EntityRefBuilder serializeTypeRef(DartType type, Element context,
       {bool linked: false, int slot}) {
     EntityRefBuilder b = new EntityRefBuilder(slot: slot);
     if (type is TypeParameterType) {
       b.paramReference = findTypeParameterIndex(type, context);
     } else {
@@ skipping 131 matching lines @@
     int slot = ++numSlots;
     if (type != null) {
       deferredLinkedTypes
           .add(() => serializeTypeRef(type, context, linked: true, slot: slot));
     }
     return slot;
   }
 
   int _getElementReferenceId(Element element, {bool linked: false}) {
     return referenceMap.putIfAbsent(element, () {
-      if (element is ConstructorElement && element.displayName.isEmpty) {
-        return _getElementReferenceId(element.enclosingElement, linked: linked);
-      }
       LibraryElement dependentLibrary = element?.library;
       int unit;
       if (dependentLibrary == null) {
         assert(element == librarySerializer.typeProvider.dynamicType.element ||
             element == null);
         unit = 0;
         dependentLibrary = librarySerializer.libraryElement;
       } else {
         CompilationUnitElement unitElement =
             element.getAncestor((Element e) => e is CompilationUnitElement);
@@ skipping 58 matching lines @@
  * Instances of this class keep track of intermediate state during
  * serialization of a single constant [Expression].
  */
 class _ConstExprSerializer extends AbstractConstExprSerializer {
   final _CompilationUnitSerializer serializer;
 
   _ConstExprSerializer(this.serializer);
 
   @override
   EntityRefBuilder serializeConstructorName(ConstructorName constructor) {
-    ConstructorElement element = constructor.staticElement;
-    assert(element != null);
-    int referenceId = serializer._getElementReferenceId(element);
-    return new EntityRefBuilder(reference: referenceId);
+    DartType type = constructor.type.type;
+    EntityRefBuilder typeRef = serializer.serializeTypeRef(type, null);
+    if (constructor.name == null) {
+      return typeRef;
+    } else {
+      int typeId = typeRef.reference;
+      LinkedReference typeLinkedRef = serializer.linkedReferences[typeId];
+      serializer.unlinkedReferences.add(new UnlinkedReferenceBuilder(
+          name: constructor.name.name, prefixReference: typeId));
+      int refId = serializer.linkedReferences.length;
+      serializer.linkedReferences.add(new LinkedReferenceBuilder(
+          kind: ReferenceKind.constructor,
+          dependency: typeLinkedRef.dependency,
+          unit: typeLinkedRef.unit));
+      return new EntityRefBuilder(
+          reference: refId, typeArguments: typeRef.typeArguments);
+    }
   }
 
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     Element element = identifier.staticElement;
     assert(element != null);
     // The only supported instance property accessor - `length`.
     if (identifier is PrefixedIdentifier &&
         element is PropertyAccessorElement &&
         !element.isStatic) {
       assert(element.name == 'length');
@@ skipping 215 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }