Tests for `void`.

pkg/compiler/lib/src/typechecker.dart

 // Copyright (c) 2012, 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.typechecker;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 634 matching lines @@
 
   ResolutionDartType visitFunctionExpression(FunctionExpression node) {
     ResolutionDartType type;
     ResolutionDartType returnType;
     final FunctionElement element = elements.getFunctionDefinition(node);
     assert(invariant(node, element != null,
         message: 'FunctionExpression with no element'));
     if (Elements.isUnresolved(element)) return const ResolutionDynamicType();
     if (element.isGenerativeConstructor) {
       type = const ResolutionDynamicType();
-      returnType = const ResolutionVoidType();
+      // TODO(floitsch): would be nice to have the voidType directly on
+      // commonElements.
+      returnType = new ResolutionVoidType(commonElements.objectClass);
 
       element.functionSignature.forEachParameter((ParameterElement parameter) {
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameter = parameter;
           checkAssignable(parameter, parameter.type,
               fieldParameter.fieldElement.computeType(resolution));
         }
       });
       if (node.initializers != null) {
         analyzeUntyped(node.initializers, inInitializer: true);
@@ skipping 1020 matching lines @@
   }
 
   /** Dart Programming Language Specification: 11.10 Return */
   visitReturn(Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
       return;
     }
 
     final Node expression = node.expression;
 
+    // TODO(floitsch): would be nice if the voidType was directly accessible
+    // from `commonElements`.
+    ResolutionVoidType voidType =
+        new ResolutionVoidType(commonElements.objectClass);
     // Executing a return statement return e; [...] It is a static type warning
     // if the type of e may not be assigned to the declared return type of the
     // immediately enclosing function.
     if (expression != null) {
       ResolutionDartType expressionType = analyze(expression);
       if (executableContext.isGenerativeConstructor) {
         // The resolver already emitted an error for this expression.
       } else {
         if (currentAsyncMarker == AsyncMarker.ASYNC) {
           ResolutionInterfaceType futureOfFlattenedType =
               commonElements.futureType(types.flatten(expressionType));
           expressionType = futureOfFlattenedType;
         }
+        // TODO(floitsch): this is probably where we want to have the checks
+        // that `void` must not have a `return` unless it returns void.
         if (expectedReturnType.isVoid &&
-            !types.isAssignable(expressionType, const ResolutionVoidType())) {
+            !types.isAssignable(expressionType, voidType)) {
           reportTypeWarning(expression, MessageKind.RETURN_VALUE_IN_VOID);
         } else {
           checkAssignable(expression, expressionType, expectedReturnType);
         }
       }
     } else if (currentAsyncMarker != AsyncMarker.SYNC) {
       // `return;` is allowed.
-    } else if (!types.isAssignable(
-        expectedReturnType, const ResolutionVoidType())) {
+    } else if (!types.isAssignable(expectedReturnType, voidType)) {
+      // TODO(floitsch): this is probably where we want to have the checks
+      // that `void` must not have a `return` unless it returns void.
+
       // Let f be the function immediately enclosing a return statement of the
       // form 'return;' It is a static warning if both of the following
       // conditions hold:
       // - f is not a generative constructor.
       // - The return type of f may not be assigned to void.
       reportTypeWarning(
           node, MessageKind.RETURN_NOTHING, {'returnType': expectedReturnType});
     }
   }
 
@@ skipping 324 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }