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

pkg/analyzer/tool/summary/idl.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 is an "idl" style description of the summary format.  It is not
  * executed directly; instead it is parsed and transformed into code that
  * implements the summary format.
  *
  * The code generation process introduces the following non-typical semantics:
@@ skipping 166 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> 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> dependencies;
 
   /**
@@ skipping 23 matching lines @@
  * Information about the resolution of an [UnlinkedReference].
  */
 class LinkedReference {
   /**
    * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   int 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 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 unit;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   int 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 name;
 }
 
 /**
  * Linked summary of a compilation unit.
  */
 class LinkedUnit {
   /**
    * Information about the resolution of references within the compilation
@@ skipping 583 matching lines @@
   @informative
   UnlinkedDocumentationComment documentationComment;
 
   /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   List<UnlinkedTypeParam> 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 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> parameters;
 
@@ skipping 177 matching lines @@
   String name;
 
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   @informative
   int 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 type;
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   List<UnlinkedParam> parameters;
 
   /**
    * Kind of the parameter.
@@ skipping 115 matching lines @@
   List<String> parts;
 }
 
 /**
  * Unlinked summary information about a name referred to in one library that
  * might be defined in another.
  */
 class 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 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 22 matching lines @@
    */
   @informative
   UnlinkedDocumentationComment documentationComment;
 
   /**
    * Type parameters of the typedef, if any.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
-   * Return type of the typedef.  Absent if the return type is `void`.
+   * Return type of the typedef.
    */
   EntityRef returnType;
 
   /**
    * Parameters of the executable, if any.
    */
   List<UnlinkedParam> parameters;
 }
 
 /**
@@ skipping 167 matching lines @@
   /**
    * If this variable is propagable, nonzero slot id identifying which entry in
    * [LinkedLibrary.types] contains the propagated type for this variable.  If
    * there is no matching entry in [LinkedLibrary.types], then this variable's
    * propagated type is the same as its declared type.
    *
    * Non-propagable variables have a [propagatedTypeSlot] of zero.
    */
   int propagatedTypeSlot;
 }