Support `void` as generic argument.

pkg/compiler/lib/src/resolution/signatures.dart

 // Copyright (c) 2014, 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 dart2js.resolution.signatures;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
@@ skipping 381 matching lines @@
     } else {
       AsyncMarker asyncMarker = AsyncMarker.SYNC;
       if (isFunctionExpression) {
         // Use async marker to determine the return type of function
         // expressions.
         FunctionElement function = element;
         asyncMarker = function.asyncMarker;
       }
       switch (asyncMarker) {
         case AsyncMarker.SYNC:
-          returnType = visitor.resolveReturnType(returnNode);
+          returnType = visitor.resolveTypeAnnotation(returnNode);
           break;
         case AsyncMarker.SYNC_STAR:
           ResolutionInterfaceType iterableType =
               resolution.commonElements.iterableType();
           returnType = iterableType;
           break;
         case AsyncMarker.ASYNC:
           ResolutionInterfaceType futureType =
               resolution.commonElements.futureType();
           returnType = futureType;
@@ skipping 62 matching lines @@
         requiredParameters: parameters,
         optionalParameters: visitor.optionalParameters,
         requiredParameterCount: requiredParameterCount,
         optionalParameterCount: visitor.optionalParameterCount,
         optionalParametersAreNamed: visitor.optionalParametersAreNamed,
         orderedOptionalParameters: orderedOptionalParameters,
         type: type);
   }
 
   ResolutionDartType resolveTypeAnnotation(TypeAnnotation annotation) {
-    ResolutionDartType type = resolveReturnType(annotation);
-    if (type.isVoid) {
-      reporter.reportErrorMessage(annotation, MessageKind.VOID_NOT_ALLOWED);
-    }
-    return type;
-  }
-
-  ResolutionDartType resolveReturnType(TypeAnnotation annotation) {
     if (annotation == null) return const ResolutionDynamicType();
     ResolutionDartType result = resolver.resolveTypeAnnotation(annotation);
     if (result == null) {
       return const ResolutionDynamicType();
     }
     return result;
   }
 }
 
 /// Used during `SignatureResolver.analyze` to provide access to the type
 /// variables of the function signature itself when its signature is analyzed.
 class FunctionSignatureBuildingScope extends TypeVariablesScope {
   @override
   final List<ResolutionDartType> typeVariables;
 
   FunctionSignatureBuildingScope(Scope parent, this.typeVariables)
       : super(parent);
 
   String toString() => 'FunctionSignatureBuildingScope($typeVariables)';
 }