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

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 550 matching lines @@
     int oldTypeParametersLength = currentTypeParameters.length;
     if (serializedExecutable.typeParameters.isNotEmpty) {
       executableElement.typeParameters =
           serializedExecutable.typeParameters.map(buildTypeParameter).toList();
       currentTypeParameters.addAll(executableElement.typeParameters);
     }
     executableElement.parameters =
         serializedExecutable.parameters.map(buildParameter).toList();
     if (serializedExecutable.returnType != null) {
       executableElement.returnType = buildType(serializedExecutable.returnType);
-    } else if (serializedExecutable.kind ==
-        UnlinkedExecutableKind.constructor) {
-      // Return type was set by the caller.
     } else {
-      executableElement.returnType = VoidTypeImpl.instance;
+      // Null return type should only be used for constructors.  Caller will
+      // handle setting the return type.
+      assert(serializedExecutable.kind == UnlinkedExecutableKind.constructor);
     }
     executableElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
         executableElement, null, oldTypeArguments, false);
     executableElement.hasImplicitReturnType =
         serializedExecutable.hasImplicitReturnType;
     executableElement.external = serializedExecutable.isExternal;
     currentTypeParameters.removeRange(
         oldTypeParametersLength, currentTypeParameters.length);
     buildDocumentation(
         executableElement, serializedExecutable.documentationComment);
@@ skipping 311 matching lines @@
           serializedParameter.name, serializedParameter.nameOffset);
     }
     if (serializedParameter.isFunctionTyped) {
       FunctionElementImpl parameterTypeElement =
           new FunctionElementImpl('', -1);
       parameterTypeElement.synthetic = true;
       parameterElement.parameters =
           serializedParameter.parameters.map(buildParameter).toList();
       parameterTypeElement.enclosingElement = parameterElement;
       parameterTypeElement.shareParameters(parameterElement.parameters);
-      if (serializedParameter.type != null) {
-        parameterTypeElement.returnType = buildType(serializedParameter.type);
-      } else {
-        parameterTypeElement.returnType = VoidTypeImpl.instance;
-      }
+      parameterTypeElement.returnType = buildType(serializedParameter.type);
       parameterElement.type = new FunctionTypeImpl.elementWithNameAndArgs(
           parameterTypeElement, null, currentTypeArguments, false);
     } else {
       if (serializedParameter.isInitializingFormal &&
           serializedParameter.hasImplicitType) {
         // The type is inherited from the matching field.
         parameterElement.type = fields[serializedParameter.name]?.type ??
             summaryResynthesizer.typeProvider.dynamicType;
       } else {
         parameterElement.type = buildType(serializedParameter.type);
@@ skipping 60 matching lines @@
       ElementLocationImpl location;
       if (referenceResolution.dependency != 0) {
         location = getReferencedLocation(
             linkedLibrary.dependencies[referenceResolution.dependency],
             referenceResolution.unit,
             name);
       } else if (referenceResolution.kind == ReferenceKind.unresolved) {
         return summaryResynthesizer.typeProvider.undefinedType;
       } else if (name == 'dynamic') {
         return summaryResynthesizer.typeProvider.dynamicType;
+      } else if (name == 'void') {
+        return VoidTypeImpl.instance;
       } else {
         String referencedLibraryUri = librarySource.uri.toString();
         String partUri;
         if (referenceResolution.unit != 0) {
           String uri = unlinkedUnits[0].publicNamespace.parts[
               referenceResolution.unit - 1];
           Source partSource =
               summaryResynthesizer.sourceFactory.resolveUri(librarySource, uri);
           partUri = partSource.uri.toString();
         } else {
@@ skipping 44 matching lines @@
           serializedTypedef.typeParameters.map(buildTypeParameter).toList();
       for (int i = 0; i < serializedTypedef.typeParameters.length; i++) {
         finishTypeParameter(
             serializedTypedef.typeParameters[i], currentTypeParameters[i]);
       }
       FunctionTypeAliasElementImpl functionTypeAliasElement =
           new FunctionTypeAliasElementImpl(
               serializedTypedef.name, serializedTypedef.nameOffset);
       functionTypeAliasElement.parameters =
           serializedTypedef.parameters.map(buildParameter).toList();
-      if (serializedTypedef.returnType != null) {
-        functionTypeAliasElement.returnType =
-            buildType(serializedTypedef.returnType);
-      } else {
-        functionTypeAliasElement.returnType = VoidTypeImpl.instance;
-      }
+      functionTypeAliasElement.returnType =
+          buildType(serializedTypedef.returnType);
       functionTypeAliasElement.type =
           new FunctionTypeImpl.forTypedef(functionTypeAliasElement);
       functionTypeAliasElement.typeParameters = currentTypeParameters;
       buildDocumentation(
           functionTypeAliasElement, serializedTypedef.documentationComment);
       unitHolder.addTypeAlias(functionTypeAliasElement);
     } finally {
       currentTypeParameters = <TypeParameterElement>[];
     }
   }
@@ skipping 135 matching lines @@
     for (PropertyAccessorElementImpl accessor in unit.accessors) {
       elementMap[accessor.identifier] = accessor;
     }
     resummarizedElements[absoluteUri] = elementMap;
     unitHolder = null;
     linkedUnit = null;
     unlinkedUnit = null;
     linkedTypeMap = null;
   }
 }