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

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

 // Copyright (c) 2016, 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.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 490 matching lines @@
 
   /**
    * Serialize a reference to a top level name declared elsewhere, by adding an
    * entry to the references table if necessary.  If [prefixIndex] is not null,
    * the reference is associated with the prefix having the given index in the
    * references table.
    */
   int serializeReference(int prefixIndex, String name) => nameToReference
           .putIfAbsent(prefixIndex, () => <String, int>{})
           .putIfAbsent(name, () {
-        assert(name != 'dynamic');
         int index = unlinkedReferences.length;
         unlinkedReferences.add(new UnlinkedReferenceBuilder(
             prefixReference: prefixIndex, name: name));
         return index;
       });
 
   /**
    * Serialize a type name (which might be defined in a nested scope, at top
    * level within this library, or at top level within an imported library) to
    * a [EntityRef].  Note that this method does the right thing if the
    * name doesn't refer to an entity other than a type (e.g. a class member).
    */
   EntityRefBuilder serializeTypeName(TypeName node, {bool allowVoid: false}) {
     EntityRefBuilder b = new EntityRefBuilder();
-    if (node != null) {
+    if (node == null) {
+      b.reference = serializeReference(null, 'dynamic');
+    } else {
       Identifier identifier = node.name;
       if (identifier is SimpleIdentifier) {
         String name = identifier.name;
         int indexOffset = 0;
         for (int i = scopes.length - 1; i >= 0; i--) {
           _Scope scope = scopes[i];
           _ScopedEntity entity = scope[name];
           if (entity != null) {
             if (entity is _ScopedTypeParameter) {
               b.paramReference = indexOffset + entity.index;
               return b;
             } else {
               // None of the other things that can be declared in local scopes
               // are types, so this is an error and should be treated as a
               // reference to `dynamic`.
+              b.reference = serializeReference(null, 'dynamic');
               return b;
             }
           }
           if (scope is _TypeParameterScope) {
             indexOffset += scope.length;
           }
         }
         if (allowVoid && name == 'void') {
           return null;
         }
-        if (name != 'dynamic') {
-          b.reference = serializeReference(null, name);
-        }
+        b.reference = serializeReference(null, name);
       } else if (identifier is PrefixedIdentifier) {
         int prefixIndex = prefixIndices.putIfAbsent(identifier.prefix.name,
             () => serializeReference(null, identifier.prefix.name));
         b.reference =
             serializeReference(prefixIndex, identifier.identifier.name);
       } else {
         throw new StateError(
             'Unexpected identifier type: ${identifier.runtimeType}');
       }
       if (node.typeArguments != null) {
@@ skipping 310 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }