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

pkg/analyzer/test/src/summary/summary_common.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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 528 matching lines @@
       {LinkedUnit linkedSourceUnit, UnlinkedUnit unlinkedSourceUnit}) {
     // When serializing from the element model, unresolved type refs lose their
     // name.
     checkTypeRef(typeRef, null, null, checkAstDerivedData ? expectedName : null,
         expectedPrefix: expectedPrefix,
         expectedKind: ReferenceKind.unresolved,
         linkedSourceUnit: linkedSourceUnit,
         unlinkedSourceUnit: unlinkedSourceUnit);
   }
 
+  /**
+   * Verify that the given [typeRef] represents the type `void`.
+   */
+  void checkVoidTypeRef(EntityRef typeRef) {
+    checkTypeRef(typeRef, null, null, 'void');
+  }
+
   fail_enum_value_documented() {
     // TODO(paulberry): currently broken because of dartbug.com/25385
     String text = '''
 enum E {
   /**
    * Docs
    */
   v
 }''';
     UnlinkedEnumValue value = serializeEnumText(text).values[0];
@@ skipping 2037 matching lines @@
             'class C { void operator[]=(int i, bool v) => null; }')
         .executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
-    expect(executable.returnType, isNull);
+    checkVoidTypeRef(executable.returnType);
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_less_equal() {
     UnlinkedExecutable executable =
         serializeClassText('class C { bool operator<=(C other) => false; }')
             .executables[0];
     expect(executable.name, '<=');
   }
 
@@ skipping 35 matching lines @@
         executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
   }
 
   test_executable_param_function_typed_return_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f(g()) {}');
     checkDynamicTypeRef(executable.parameters[0].type);
   }
 
   test_executable_param_function_typed_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('f(void g()) {}');
-    expect(executable.parameters[0].type, isNull);
+    checkVoidTypeRef(executable.parameters[0].type);
   }
 
   test_executable_param_kind_named() {
     UnlinkedExecutable executable = serializeExecutableText('f({x}) {}');
     expect(executable.parameters[0].kind, UnlinkedParamKind.named);
   }
 
   test_executable_param_kind_positional() {
     UnlinkedExecutable executable = serializeExecutableText('f([x]) {}');
     expect(executable.parameters[0].kind, UnlinkedParamKind.positional);
@@ skipping 54 matching lines @@
   }
 
   test_executable_return_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     checkDynamicTypeRef(executable.returnType);
     expect(executable.hasImplicitReturnType, isTrue);
   }
 
   test_executable_return_type_void() {
     UnlinkedExecutable executable = serializeExecutableText('void f() {}');
-    expect(executable.returnType, isNull);
+    checkVoidTypeRef(executable.returnType);
   }
 
   test_executable_setter() {
     String text = 'void set f(value) {}';
     UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
@@ skipping 18 matching lines @@
   }
 
   test_executable_setter_private() {
     serializeExecutableText('void set _f(value) {}', '_f=');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 
   test_executable_setter_type() {
     UnlinkedExecutable executable =
         serializeExecutableText('void set f(int value) {}', 'f=');
-    expect(executable.returnType, isNull);
+    checkVoidTypeRef(executable.returnType);
     expect(executable.parameters, hasLength(1));
     expect(executable.parameters[0].name, 'value');
     checkTypeRef(
         executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
   }
 
   test_executable_static() {
     UnlinkedExecutable executable =
         serializeClassText('class C { static f() {} }').executables[0];
     expect(executable.isStatic, isTrue);
@@ skipping 1433 matching lines @@
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
     expect(constExpr.doubles, doubles);
     expect(constExpr.strings, strings);
     expect(constExpr.references, hasLength(referenceValidators.length));
     for (int i = 0; i < referenceValidators.length; i++) {
       referenceValidators[i](constExpr.references[i]);
     }
   }
 }