Support for constructor references in constant serializer and prelinker.

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 11 matching lines @@
 LibrarySerializationResult serializeLibrary(
     LibraryElement lib, TypeProvider typeProvider, bool strongMode) {
   var serializer = new _LibrarySerializer(lib, typeProvider, strongMode);
   LinkedLibraryBuilder linked = serializer.serializeLibrary();
   return new LibrarySerializationResult(
       linked, serializer.unlinkedUnits, serializer.unitUris);
 }
 
 ReferenceKind _getReferenceKind(Element element) {
   ReferenceKind kind;
-  if (element is PropertyAccessorElement) {
-    kind = ReferenceKind.topLevelPropertyAccessor;
-  } else if (element is FunctionTypeAliasElement) {
-    kind = ReferenceKind.typedef;
-  } else if (element == null ||
+  if (element == null ||
       element is ClassElement ||
       element is DynamicElementImpl) {
     kind = ReferenceKind.classOrEnum;
+  } else if (element is ConstructorElement) {
+    kind = ReferenceKind.constructor;
   } else if (element is FunctionElement) {
     kind = ReferenceKind.topLevelFunction;
+  } else if (element is FunctionTypeAliasElement) {
+    kind = ReferenceKind.typedef;
+  } else if (element is PropertyAccessorElement) {
+    kind = ReferenceKind.topLevelPropertyAccessor;
   } else {
     throw new Exception('Unexpected element kind: ${element.runtimeType}');
   }
   return kind;
 }
 
 /**
  * Type of closures used by [_LibrarySerializer] to defer generation of
  * [EntityRefBuilder] objects until the end of serialization of a
  * compilation unit.
@@ skipping 726 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);
         unit = dependentLibrary.units.indexOf(unitElement);
         assert(unit != -1);
       }
       int numTypeParameters = 0;
       if (element is TypeParameterizedElement) {
         numTypeParameters = element.typeParameters.length;
       }
       LinkedReferenceBuilder linkedReference = new LinkedReferenceBuilder(
           dependency: librarySerializer.serializeDependency(dependentLibrary),
           kind: _getReferenceKind(element),
           unit: unit,
           numTypeParameters: numTypeParameters);
       String name = element == null ? 'void' : element.name;
       if (linked) {
         linkedReference.name = name;
       } else {
         assert(unlinkedReferences.length == linkedReferences.length);
-        // Figure out a prefix that may be used to refer to the given type.
-        // TODO(paulberry): to avoid subtle relinking inconsistencies we
-        // should use the actual prefix from the AST (a given type may be
-        // reachable via multiple prefixes), but sadly, this information is
-        // not recorded in the element model.
         int prefixReference = 0;
-        PrefixElement prefix = librarySerializer.prefixMap[element];
-        if (prefix != null) {
-          prefixReference = serializePrefix(prefix);
+        Element enclosing = element?.enclosingElement;
+        if (enclosing == null || enclosing is CompilationUnitElement) {
+          // Figure out a prefix that may be used to refer to the given element.
+          // TODO(paulberry): to avoid subtle relinking inconsistencies we
+          // should use the actual prefix from the AST (a given type may be
+          // reachable via multiple prefixes), but sadly, this information is
+          // not recorded in the element model.
+          PrefixElement prefix = librarySerializer.prefixMap[element];
+          if (prefix != null) {
+            prefixReference = serializePrefix(prefix);
+          }
+        } else {
+          prefixReference = _getElementReferenceId(enclosing, linked: linked);
         }
         unlinkedReferences.add(new UnlinkedReferenceBuilder(
             name: name, prefixReference: prefixReference));
       }
       int index = linkedReferences.length;
       linkedReferences.add(linkedReference);
       return index;
     });
   }
 }
 
 /**
  * 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);
+  }
+
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     Element element = identifier.staticElement;
     assert(element != null);
     // TODO(scheglov) how to serialize element references?
     return new EntityRefBuilder(
         reference: serializer._getElementReferenceId(element));
   }
 
   @override
   EntityRefBuilder serializeType(TypeName typeName) {
@@ skipping 185 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }