Use the explicit string 'dynamic' to refer to dynamic in summaries.

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 15 matching lines @@
   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 is ClassElement) {
+  } else if (element is ClassElement || element is DynamicElementImpl) {
     kind = ReferenceKind.classOrEnum;
   } else if (element is FunctionElement) {
     kind = ReferenceKind.topLevelFunction;
   } else {
     throw new Exception('Unexpected element kind: ${element.runtimeType}');
   }
   return kind;
 }
 
 /**
@@ skipping 356 matching lines @@
     if (element.documentationComment == null) {
       return null;
     }
     return new UnlinkedDocumentationCommentBuilder(
         text: element.documentationComment,
         offset: element.docRange.offset,
         length: element.docRange.length);
   }
 
   /**
-   * Return the index of the entry in the references table
-   * ([UnlinkedLibrary.references] and [LinkedLibrary.references])
-   * representing the pseudo-type `dynamic`.
-   */
-  int serializeDynamicReference() => 0;
-
-  /**
    * Serialize the given [enumElement], creating an [UnlinkedEnum].
    */
   UnlinkedEnumBuilder serializeEnum(ClassElement enumElement) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder();
     b.name = enumElement.name;
     b.nameOffset = enumElement.nameOffset;
     List<UnlinkedEnumValueBuilder> values = <UnlinkedEnumValueBuilder>[];
     for (FieldElement field in enumElement.fields) {
       if (field.isConst && field.type.element == enumElement) {
         values.add(new UnlinkedEnumValueBuilder(
@@ skipping 163 matching lines @@
    * If [linked] is true, and a new reference has to be created, the reference
    * will only be stored in [linkedReferences].
    */
   int serializeReferenceForType(DartType type, bool linked) {
     Element element = type.element;
     LibraryElement dependentLibrary = element.library;
     if (dependentLibrary == null) {
       assert(type.isDynamic);
       if (type is UndefinedTypeImpl) {
         return serializeUnresolvedReference();
-      } else {
-        return serializeDynamicReference();
       }
-    } else {
-      return _getElementReferenceId(element, linked: linked);
+      // Note: for a type which is truly `dynamic`, fall through to use
+      // [_getElementReferenceId].
     }
+    return _getElementReferenceId(element, linked: linked);
   }
 
   /**
    * Serialize the given [typedefElement], creating an [UnlinkedTypedef].
    */
   UnlinkedTypedefBuilder serializeTypedef(
       FunctionTypeAliasElement typedefElement) {
     UnlinkedTypedefBuilder b = new UnlinkedTypedefBuilder();
     b.name = typedefElement.name;
     b.nameOffset = typedefElement.nameOffset;
@@ skipping 131 matching lines @@
   int storeLinkedType(DartType type, Element context) {
     int slot = ++numSlots;
     if (type != null) {
       deferredLinkedTypes
           .add(() => serializeTypeRef(type, context, linked: true, slot: slot));
     }
     return slot;
   }
 
   int _getElementReferenceId(Element element, {bool linked: false}) {
-    LibraryElement dependentLibrary = element.library;
     return referenceMap.putIfAbsent(element, () {
-      CompilationUnitElement unitElement =
-          element.getAncestor((Element e) => e is CompilationUnitElement);
-      int unit = dependentLibrary.units.indexOf(unitElement);
-      assert(unit != -1);
+      LibraryElement dependentLibrary = element.library;
+      int unit;
+      if (element.library == null) {
+        assert(element == librarySerializer.typeProvider.dynamicType.element);
+        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);
       if (linked) {
@@ skipping 221 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }