Reserve element 0 in the references table for `dynamic`.

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/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 75 matching lines @@
 
   /**
    * The prelinked portion of the "references table".  This is the list of
    * objects which should be written to [PrelinkedUnit.references].
    */
   List<PrelinkedReferenceBuilder> prelinkedReferences;
 
   //final Map<String, int> prefixIndices = <String, int>{};
 
   /**
-   * Index into the "references table" representing `dynamic`, if such an index
-   * exists.  `null` if no such entry has been made in the references table
-   * yet.
-   */
-  int dynamicReferenceIndex = null;
-
-  /**
    * Index into the "references table" representing an unresolved reference, if
    * such an index exists.  `null` if no such entry has been made in the
    * references table yet.
    */
   int unresolvedReferenceIndex = null;
 
   /**
    * Set of libraries which have been seen so far while visiting the transitive
    * closure of exports.
    */
@@ skipping 34 matching lines @@
       if (libraryElement.name.isNotEmpty) {
         b.libraryName = libraryElement.name;
       }
       b.exports = libraryElement.exports.map(serializeExport).toList();
       b.imports = libraryElement.imports.map(serializeImport).toList();
       b.parts = libraryElement.parts
           .map(
               (CompilationUnitElement e) => encodeUnlinkedPart(ctx, uri: e.uri))
           .toList();
     }
-    unlinkedReferences = <UnlinkedReferenceBuilder>[];
-    prelinkedReferences = <PrelinkedReferenceBuilder>[];
+    unlinkedReferences = <UnlinkedReferenceBuilder>[
+      encodeUnlinkedReference(ctx)
+    ];
+    prelinkedReferences = <PrelinkedReferenceBuilder>[
+      encodePrelinkedReference(ctx, kind: PrelinkedReferenceKind.classOrEnum)
+    ];
     b.classes = element.types.map(serializeClass).toList();
     b.enums = element.enums.map(serializeEnum).toList();
     b.typedefs = element.functionTypeAliases.map(serializeTypedef).toList();
     List<UnlinkedExecutableBuilder> executables =
         element.functions.map(serializeExecutable).toList();
     for (PropertyAccessorElement accessor in element.accessors) {
       if (!accessor.isSynthetic) {
         executables.add(serializeExecutable(accessor));
       }
     }
@@ skipping 134 matching lines @@
       int index = dependencies.length;
       dependencies.add(encodePrelinkedDependency(ctx,
           uri: dependentLibrary.source.uri.toString()));
       return index;
     });
   }
 
   /**
    * Return the index of the entry in the references table
    * ([UnlinkedLibrary.references] and [PrelinkedLibrary.references])
-   * representing the pseudo-type `dynamic`.  A new entry is added to the table
-   * if necessary to satisfy the request.
+   * representing the pseudo-type `dynamic`.
    */
-  int serializeDynamicReference() {
-    if (dynamicReferenceIndex == null) {
-      assert(unlinkedReferences.length == prelinkedReferences.length);
-      dynamicReferenceIndex = unlinkedReferences.length;
-      unlinkedReferences.add(encodeUnlinkedReference(ctx));
-      prelinkedReferences.add(encodePrelinkedReference(ctx,
-          kind: PrelinkedReferenceKind.classOrEnum));
-    }
-    return dynamicReferenceIndex;
-  }
+  int serializeDynamicReference() => 0;
 
   /**
    * Serialize the given [enumElement], creating an [UnlinkedEnum].
    */
   UnlinkedEnumBuilder serializeEnum(ClassElement enumElement) {
     UnlinkedEnumBuilder b = new UnlinkedEnumBuilder(ctx);
     b.name = enumElement.name;
     List<UnlinkedEnumValueBuilder> values = <UnlinkedEnumValueBuilder>[];
     for (FieldElement field in enumElement.fields) {
       if (field.isConst && field.type.element == enumElement) {
@@ skipping 237 matching lines @@
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     return b;
   }
 }