Use the explicit string 'void' to refer to void 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 || element is DynamicElementImpl) {
+  } else if (element == null ||
+      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 392 matching lines @@
     b.name = executableElement.name;
     b.nameOffset = executableElement.nameOffset;
     if (executableElement is! ConstructorElement) {
       if (executableElement.hasImplicitReturnType) {
         // In strong mode, the variable's static type may have been overwritten
         // by an inferred type.  In this part of the summary we want to store
         // the weak mode static type (which is `dynamic`), since the strong
         // mode static type is fully linked information.
         b.returnType = serializeTypeRef(
             librarySerializer.typeProvider.dynamicType, executableElement);
-      } else if (!executableElement.type.returnType.isVoid) {
+      } else {
         b.returnType = serializeTypeRef(
             executableElement.type.returnType, executableElement);
       }
     }
     b.typeParameters =
         executableElement.typeParameters.map(serializeTypeParam).toList();
     b.parameters =
         executableElement.type.parameters.map(serializeParam).toList();
     if (executableElement is PropertyAccessorElement) {
       if (executableElement.isGetter) {
@@ skipping 85 matching lines @@
     }
     b.isInitializingFormal = parameter.isInitializingFormal;
     DartType type = parameter.type;
     if (parameter.isInitializingFormal && parameter.hasImplicitType) {
       b.hasImplicitType = true;
       // We don't store the type of initializing formals that have an implicit
       // type, because the type is inherited from the field.
     } else {
       if (type is FunctionType) {
         b.isFunctionTyped = true;
-        if (!type.returnType.isVoid) {
-          b.type = serializeTypeRef(type.returnType, parameter);
-        }
+        b.type = serializeTypeRef(type.returnType, parameter);
         b.parameters = type.parameters
             .map((parameter) => serializeParam(parameter, context))
             .toList();
       } else {
         b.type = serializeTypeRef(type, context);
         b.hasImplicitType = parameter.hasImplicitType;
       }
     }
     return b;
   }
@@ skipping 13 matching lines @@
   }
 
   /**
    * Compute the reference index which should be stored in a [EntityRef].
    *
    * 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;
+    LibraryElement dependentLibrary = element?.library;
     if (dependentLibrary == null) {
-      assert(type.isDynamic);
+      assert(type.isDynamic || type.isVoid);
       if (type is UndefinedTypeImpl) {
         return serializeUnresolvedReference();
       }
-      // Note: for a type which is truly `dynamic`, fall through to use
-      // [_getElementReferenceId].
+      // Note: for a type which is truly `dynamic` or `void`, 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;
     b.typeParameters =
         typedefElement.typeParameters.map(serializeTypeParam).toList();
-    if (!typedefElement.returnType.isVoid) {
-      b.returnType =
-          serializeTypeRef(typedefElement.returnType, typedefElement);
-    }
+    b.returnType = serializeTypeRef(typedefElement.returnType, typedefElement);
     b.parameters = typedefElement.parameters.map(serializeParam).toList();
     b.documentationComment = serializeDocumentation(typedefElement);
     return b;
   }
 
   /**
    * Serialize the given [typeParameter] into an [UnlinkedTypeParam].
    */
   UnlinkedTypeParamBuilder serializeTypeParam(
       TypeParameterElement typeParameter) {
@@ skipping 116 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, () {
-      LibraryElement dependentLibrary = element.library;
+      LibraryElement dependentLibrary = element?.library;
       int unit;
-      if (element.library == null) {
-        assert(element == librarySerializer.typeProvider.dynamicType.element);
+      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);
+            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 = element.name;
+        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);
         }
         unlinkedReferences.add(new UnlinkedReferenceBuilder(
-            name: element.name, prefixReference: prefixReference));
+            name: name, prefixReference: prefixReference));
       }
       int index = linkedReferences.length;
       linkedReferences.add(linkedReference);
       return index;
     });
   }
 }
 
 /**
  * Instances of this class keep track of intermediate state during
@@ skipping 196 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }