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

pkg/analyzer/lib/src/summary/format.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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script "pkg/analyzer/tool/generate_files".
 
 library analyzer.src.summary.format;
 
 import 'base.dart' as base;
@@ skipping 929 matching lines @@
     _units = _value;
   }
 
   @override
   List<LinkedDependencyBuilder> get dependencies => _dependencies ??= <LinkedDependencyBuilder>[];
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
-   * representing the library itself (it is also used for "dynamic").  This is
-   * followed by elements representing "prelinked" dependencies (direct imports
-   * and the transitive closure of exports).  After the prelinked dependencies
-   * are elements represent "linked" dependencies.
+   * representing the library itself (it is also used for `dynamic` and
+   * `void`).  This is followed by elements representing "prelinked"
+   * dependencies (direct imports and the transitive closure of exports).
+   * After the prelinked dependencies are elements representing "linked"
+   * dependencies.
    *
    * A library is only included as a "linked" dependency if it is a true
    * dependency (e.g. a propagated or inferred type or constant value
    * implicitly refers to an element declared in the library) or
    * anti-dependency (e.g. the result of type propagation or type inference
    * depends on the lack of a certain declaration in the library).
    */
   void set dependencies(List<LinkedDependencyBuilder> _value) {
     assert(!_finished);
     _dependencies = _value;
@@ skipping 106 matching lines @@
    * library.  The summary of the defining compilation unit is listed first,
    * followed by the summary of each part, in the order of the `part`
    * declarations in the defining compilation unit.
    */
   List<LinkedUnit> get units;
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
-   * representing the library itself (it is also used for "dynamic").  This is
-   * followed by elements representing "prelinked" dependencies (direct imports
-   * and the transitive closure of exports).  After the prelinked dependencies
-   * are elements represent "linked" dependencies.
+   * representing the library itself (it is also used for `dynamic` and
+   * `void`).  This is followed by elements representing "prelinked"
+   * dependencies (direct imports and the transitive closure of exports).
+   * After the prelinked dependencies are elements representing "linked"
+   * dependencies.
    *
    * A library is only included as a "linked" dependency if it is a true
    * dependency (e.g. a propagated or inferred type or constant value
    * implicitly refers to an element declared in the library) or
    * anti-dependency (e.g. the result of type propagation or type inference
    * depends on the lack of a certain declaration in the library).
    */
   List<LinkedDependency> get dependencies;
 
   /**
@@ skipping 98 matching lines @@
   void set dependency(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _dependency = _value;
   }
 
   @override
   ReferenceKind get kind => _kind ??= ReferenceKind.classOrEnum;
 
   /**
-   * The kind of the entity being referred to.  For the pseudo-type `dynamic`,
-   * the kind is [ReferenceKind.classOrEnum].
+   * The kind of the entity being referred to.  For the pseudo-types `dynamic`
+   * and `void`, the kind is [ReferenceKind.classOrEnum].
    */
   void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
   int get unit => _unit ??= 0;
 
   /**
@@ skipping 20 matching lines @@
     assert(_value == null || _value >= 0);
     _numTypeParameters = _value;
   }
 
   @override
   String get name => _name ??= '';
 
   /**
    * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
    * name of the entity being referred to.  For the pseudo-type `dynamic`, the
-   * string is "dynamic".
+   * string is "dynamic".  For the pseudo-type `void`, the string is "void".
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   LinkedReferenceBuilder({int dependency, ReferenceKind kind, int unit, int numTypeParameters, String name})
     : _dependency = dependency,
       _kind = kind,
       _unit = unit,
@@ skipping 32 matching lines @@
  */
 abstract class LinkedReference extends base.SummaryClass {
 
   /**
    * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   int get dependency;
 
   /**
-   * The kind of the entity being referred to.  For the pseudo-type `dynamic`,
-   * the kind is [ReferenceKind.classOrEnum].
+   * The kind of the entity being referred to.  For the pseudo-types `dynamic`
+   * and `void`, the kind is [ReferenceKind.classOrEnum].
    */
   ReferenceKind get kind;
 
   /**
    * Integer index indicating which unit in the imported library contains the
    * definition of the entity.  As with indices into [LinkedLibrary.units],
    * zero represents the defining compilation unit, and nonzero values
    * represent parts in the order of the corresponding `part` declarations.
    */
   int get unit;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   int get numTypeParameters;
 
   /**
    * If this [LinkedReference] doesn't have an associated [UnlinkedReference],
    * name of the entity being referred to.  For the pseudo-type `dynamic`, the
-   * string is "dynamic".
+   * string is "dynamic".  For the pseudo-type `void`, the string is "void".
    */
   String get name;
 }
 
 class _LinkedReferenceReader extends fb.TableReader<_LinkedReferenceImpl> {
   const _LinkedReferenceReader();
 
   @override
   _LinkedReferenceImpl createObject(fb.BufferPointer bp) => new _LinkedReferenceImpl(bp);
 }
@@ skipping 1630 matching lines @@
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
   EntityRefBuilder get returnType => _returnType;
 
   /**
-   * Declared return type of the executable.  Absent if the return type is
-   * `void` or the executable is a constructor.  Note that when strong mode is
-   * enabled, the actual return type may be different due to type inference.
+   * Declared return type of the executable.  Absent if the executable is a
+   * constructor.  Note that when strong mode is enabled, the actual return
+   * type may be different due to type inference.
    */
   void set returnType(EntityRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
   @override
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
@@ skipping 198 matching lines @@
    */
   UnlinkedDocumentationComment get documentationComment;
 
   /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   List<UnlinkedTypeParam> get typeParameters;
 
   /**
-   * Declared return type of the executable.  Absent if the return type is
-   * `void` or the executable is a constructor.  Note that when strong mode is
-   * enabled, the actual return type may be different due to type inference.
+   * Declared return type of the executable.  Absent if the executable is a
+   * constructor.  Note that when strong mode is enabled, the actual return
+   * type may be different due to type inference.
    */
   EntityRef get returnType;
 
   /**
    * Parameters of the executable, if any.  Note that getters have no
    * parameters (hence this will be the empty list), and setters have a single
    * parameter.
    */
   List<UnlinkedParam> get parameters;
 
@@ skipping 766 matching lines @@
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _nameOffset = _value;
   }
 
   @override
   EntityRefBuilder get type => _type;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
-   * [isFunctionTyped] is `false`, the declared type.  Absent if
-   * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
-   * that when strong mode is enabled, the actual type may be different due to
-   * type inference.
+   * [isFunctionTyped] is `false`, the declared type.
    */
   void set type(EntityRefBuilder _value) {
     assert(!_finished);
     _type = _value;
   }
 
   @override
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
@@ skipping 114 matching lines @@
    */
   String get name;
 
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   int get nameOffset;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
-   * [isFunctionTyped] is `false`, the declared type.  Absent if
-   * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
-   * that when strong mode is enabled, the actual type may be different due to
-   * type inference.
+   * [isFunctionTyped] is `false`, the declared type.
    */
   EntityRef get type;
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   List<UnlinkedParam> get parameters;
 
   /**
    * Kind of the parameter.
@@ skipping 511 matching lines @@
   bool _finished = false;
 
   String _name;
   int _prefixReference;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the entity being referred to.  For the pseudo-type `dynamic`, the
-   * string is "dynamic".
+   * string is "dynamic".  For the pseudo-type `void`, the string is "void".
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
   int get prefixReference => _prefixReference ??= 0;
 
   /**
@@ skipping 33 matching lines @@
 }
 
 /**
  * Unlinked summary information about a name referred to in one library that
  * might be defined in another.
  */
 abstract class UnlinkedReference extends base.SummaryClass {
 
   /**
    * Name of the entity being referred to.  For the pseudo-type `dynamic`, the
-   * string is "dynamic".
+   * string is "dynamic".  For the pseudo-type `void`, the string is "void".
    */
   String get name;
 
   /**
    * Prefix used to refer to the entity, or zero if no prefix is used.  This is
    * an index into [UnlinkedUnit.references].
    *
    * Prefix references must always point backward; that is, for all i, if
    * UnlinkedUnit.references[i].prefixReference != 0, then
    * UnlinkedUnit.references[i].prefixReference < i.
@@ skipping 90 matching lines @@
    */
   void set typeParameters(List<UnlinkedTypeParamBuilder> _value) {
     assert(!_finished);
     _typeParameters = _value;
   }
 
   @override
   EntityRefBuilder get returnType => _returnType;
 
   /**
-   * Return type of the typedef.  Absent if the return type is `void`.
+   * Return type of the typedef.
    */
   void set returnType(EntityRefBuilder _value) {
     assert(!_finished);
     _returnType = _value;
   }
 
   @override
   List<UnlinkedParamBuilder> get parameters => _parameters ??= <UnlinkedParamBuilder>[];
 
   /**
@@ skipping 78 matching lines @@
    * documentation comment.
    */
   UnlinkedDocumentationComment get documentationComment;
 
   /**
    * Type parameters of the typedef, if any.
    */
   List<UnlinkedTypeParam> get typeParameters;
 
   /**
-   * Return type of the typedef.  Absent if the return type is `void`.
+   * Return type of the typedef.
    */
   EntityRef get returnType;
 
   /**
    * Parameters of the executable, if any.
    */
   List<UnlinkedParam> get parameters;
 }
 
 class _UnlinkedTypedefReader extends fb.TableReader<_UnlinkedTypedefImpl> {
@@ skipping 1089 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
     "propagatedTypeSlot": propagatedTypeSlot,
   };
 }