Support `void` as generic argument.

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 400 matching lines @@
       reportedTypePromotions.add(typePromotion);
       for (TypePromotionMessage message in typePromotion.messages) {
         reporter.reportHint(message.hint, message.infos);
       }
     }
   }
 
   // TODO(karlklose): remove these functions.
   ResolutionDartType unhandledExpression() => const ResolutionDynamicType();
 
+  /// Checks that the analyzed node is not `void`.
+  ///
+  /// If it is, a warning is emitted, and the returned type is `dynamic`.
   ResolutionDartType analyzeNonVoid(Node node) {
     ResolutionDartType type = analyze(node);
     if (type.isVoid) {
       reportTypeWarning(node, MessageKind.VOID_EXPRESSION);
+      return const ResolutionDynamicType();
     }
     return type;
   }
 
   ResolutionDartType analyzeWithDefault(
       Node node, ResolutionDartType defaultValue) {
     return node != null ? analyze(node) : defaultValue;
   }
 
   /// If [inInitializer] is true, assignment should be interpreted as write to
@@ skipping 98 matching lines @@
     }
 
     for (TypePromotion typePromotion in getShownTypePromotionsFor(right)) {
       typePromotion = typePromotion.copy();
       checkTypePromotion(right, typePromotion);
       showTypePromotion(node, typePromotion);
     }
   }
 
   /// Analyze [node] in the context of the known types shown in [context].
+  ///
+  /// If the node [mustHaveType] then it must also not be void.
   ResolutionDartType analyzeInPromotedContext(Node context, Node node,
       {bool mustHaveType: true}) {
     Link<TypePromotion> knownForNode = const Link<TypePromotion>();
     for (TypePromotion typePromotion in getShownTypePromotionsFor(context)) {
       typePromotion = typePromotion.copy();
       checkTypePromotion(node, typePromotion, checkAccesses: true);
       knownForNode = knownForNode.prepend(typePromotion);
       registerKnownTypePromotion(typePromotion);
     }
 
-    final ResolutionDartType type = analyze(node, mustHaveType: mustHaveType);
+    final ResolutionDartType type = mustHaveType
+        ? analyzeNonVoid(node)
+        : analyze(node, mustHaveType: false);
 
     while (!knownForNode.isEmpty) {
       unregisterKnownTypePromotion(knownForNode.head);
       knownForNode = knownForNode.tail;
     }
 
     return type;
   }
 
   /**
@@ skipping 11 matching lines @@
       } else {
         reporter.reportWarningMessage(spannable, MessageKind.NOT_ASSIGNABLE,
             {'fromType': from, 'toType': to});
       }
       return false;
     }
     return true;
   }
 
   checkCondition(Expression condition) {
-    checkAssignable(condition, analyze(condition), boolType);
+    checkAssignable(condition, analyzeNonVoid(condition), boolType);
   }
 
   void pushCascadeType(ResolutionDartType type) {
     cascadeTypes = cascadeTypes.prepend(type);
   }
 
   ResolutionDartType popCascadeType() {
     ResolutionDartType type = cascadeTypes.head;
     cascadeTypes = cascadeTypes.tail;
     return type;
   }
 
   visitAssert(Assert node) {
-    analyze(node.condition);
-    if (node.hasMessage) analyze(node.message);
+    analyzeNonVoid(node.condition);
+    if (node.hasMessage) analyzeNonVoid(node.message);
   }
 
   visitBlock(Block node) {
     analyzeUntyped(node.statements);
   }
 
   ResolutionDartType visitCascade(Cascade node) {
     analyze(node.expression);
     return popCascadeType();
   }
 
   ResolutionDartType visitCascadeReceiver(CascadeReceiver node) {
-    ResolutionDartType type = analyze(node.expression);
+    ResolutionDartType type = analyzeNonVoid(node.expression);
     pushCascadeType(type);
     return type;
   }
 
   visitDoWhile(DoWhile node) {
     analyzeUntyped(node.body);
     checkCondition(node.condition);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
@@ skipping 309 matching lines @@
           ResolutionDartType namedParameterType =
               funType.getNamedParameterType(argumentName);
           if (namedParameterType == null) {
             // TODO(johnniwinther): Provide better information on the called
             // function.
             reportWarning(reporter.createMessage(
                 argument,
                 MessageKind.NAMED_ARGUMENT_NOT_FOUND,
                 {'argumentName': argumentName}));
 
-            ResolutionDartType argumentType = analyze(argument);
+            ResolutionDartType argumentType = analyzeNonVoid(argument);
             if (argumentTypes != null) argumentTypes.addLast(argumentType);
           } else {
-            ResolutionDartType argumentType = analyze(argument);
+            ResolutionDartType argumentType = analyzeNonVoid(argument);
             if (argumentTypes != null) argumentTypes.addLast(argumentType);
             checkAssignable(argument, argumentType, namedParameterType);
           }
         } else {
           if (!parameterTypes.moveNext()) {
             if (!optionalParameterTypes.moveNext()) {
               // TODO(johnniwinther): Provide better information on the
               // called function.
               reportWarning(reporter.createMessage(
                   argument, MessageKind.ADDITIONAL_ARGUMENT));
 
-              ResolutionDartType argumentType = analyze(argument);
+              ResolutionDartType argumentType = analyzeNonVoid(argument);
               if (argumentTypes != null) argumentTypes.addLast(argumentType);
             } else {
-              ResolutionDartType argumentType = analyze(argument);
+              ResolutionDartType argumentType = analyzeNonVoid(argument);
               if (argumentTypes != null) argumentTypes.addLast(argumentType);
               checkAssignable(
                   argument, argumentType, optionalParameterTypes.current);
             }
           } else {
-            ResolutionDartType argumentType = analyze(argument);
+            ResolutionDartType argumentType = analyzeNonVoid(argument);
             if (argumentTypes != null) argumentTypes.addLast(argumentType);
             checkAssignable(argument, argumentType, parameterTypes.current);
           }
         }
         arguments = arguments.tail;
       }
       if (parameterTypes.moveNext()) {
         // TODO(johnniwinther): Provide better information on the called
         // function.
         reportWarning(reporter.createMessage(send, MessageKind.MISSING_ARGUMENT,
             {'argumentType': parameterTypes.current}));
       }
     } else {
       while (!arguments.isEmpty) {
-        ResolutionDartType argumentType = analyze(arguments.head);
+        ResolutionDartType argumentType = analyzeNonVoid(arguments.head);
         if (argumentTypes != null) argumentTypes.addLast(argumentType);
         arguments = arguments.tail;
       }
     }
   }
 
   // Analyze the invocation [node] of [elementAccess].
   //
   // If provided [argumentTypes] is filled with the argument types during
   // analysis.
@@ skipping 35 matching lines @@
           if (node.isConditional) {
             // Skip cases like `prefix?.topLevel`.
             return const DynamicAccess();
           }
           assert(invariant(node, element != null,
               message: 'Prefixed node has no element.'));
           return computeResolvedAccess(node, name, element, memberKind);
         }
       }
       // e.foo() for some expression e.
-      ResolutionDartType receiverType = analyze(node.receiver);
-      if (receiverType.treatAsDynamic || receiverType.isVoid) {
+      ResolutionDartType receiverType = analyzeNonVoid(node.receiver);
+      if (receiverType.treatAsDynamic) {
         return const DynamicAccess();
       }
       return lookupMember(
           node, receiverType, name, memberKind, elements[node.receiver],
           lookupClassMember:
               lookupClassMember || element != null && element.isStatic);
     } else {
       return computeResolvedAccess(node, name, element, memberKind);
     }
   }
@@ skipping 204 matching lines @@
           }
         }
       }
       return boolType;
     }
     if (node.isOperator && identical(name, 'as')) {
       analyze(node.receiver);
       return elements.getType(node.arguments.head);
     } else if (node.isOperator) {
       final Node receiver = node.receiver;
-      final ResolutionDartType receiverType = analyze(receiver);
+      final ResolutionDartType receiverType = analyzeNonVoid(receiver);
       if (identical(name, '==') ||
           identical(name, '!=')
           // TODO(johnniwinther): Remove these.
           ||
           identical(name, '===') ||
           identical(name, '!==')) {
         // Analyze argument.
-        analyze(node.arguments.head);
+        analyzeNonVoid(node.arguments.head);
         return boolType;
       } else if (identical(name, '||')) {
         checkAssignable(receiver, receiverType, boolType);
         final Node argument = node.arguments.head;
-        final ResolutionDartType argumentType = analyze(argument);
+        final ResolutionDartType argumentType = analyzeNonVoid(argument);
         checkAssignable(argument, argumentType, boolType);
         return boolType;
       } else if (identical(name, '&&')) {
         checkAssignable(receiver, receiverType, boolType);
         final Node argument = node.arguments.head;
 
         final ResolutionDartType argumentType =
             analyzeInPromotedContext(receiver, argument);
 
         reshowTypePromotions(node, receiver, argument);
 
         checkAssignable(argument, argumentType, boolType);
         return boolType;
       } else if (identical(name, '!')) {
         checkAssignable(receiver, receiverType, boolType);
         return boolType;
       } else if (identical(name, '?')) {
         return boolType;
       } else if (identical(name, '??')) {
         final Node argument = node.arguments.head;
-        final ResolutionDartType argumentType = analyze(argument);
+        final ResolutionDartType argumentType = analyzeNonVoid(argument);
         return types.computeLeastUpperBound(receiverType, argumentType);
       }
       String operatorName = selector.source;
       if (identical(name, '-') && node.arguments.isEmpty) {
         operatorName = 'unary-';
       }
       assert(invariant(
           node,
           identical(name, '+') ||
               identical(name, '=') ||
               identical(name, '-') ||
               identical(name, '*') ||
               identical(name, '/') ||
               identical(name, '%') ||
               identical(name, '~/') ||
               identical(name, '|') ||
               identical(name, '&') ||
               identical(name, '^') ||
               identical(name, '~') ||
               identical(name, '<<') ||
               identical(name, '>>') ||
               identical(name, '<') ||
               identical(name, '>') ||
               identical(name, '<=') ||
               identical(name, '>=') ||
               identical(name, '[]'),
           message: 'Unexpected operator $name'));
 
-      // TODO(karlklose): handle `void` in expression context by calling
-      // [analyzeNonVoid] instead of [analyze].
-      ElementAccess access = receiverType.isVoid
-          ? const DynamicAccess()
-          : lookupMember(
+      ElementAccess access = lookupMember(
               node, receiverType, operatorName, MemberKind.OPERATOR, null);
       LinkBuilder<ResolutionDartType> argumentTypesBuilder =
           new LinkBuilder<ResolutionDartType>();
       ResolutionDartType resultType =
           analyzeInvocation(node, access, argumentTypesBuilder);
       if (receiverType == intType) {
         if (identical(name, '+') ||
             identical(operatorName, '-') ||
             identical(name, '*') ||
             identical(name, '%')) {
@@ skipping 38 matching lines @@
    * like [: target++ :].
    */
   ResolutionDartType checkAssignmentOperator(SendSet node, String operatorName,
       Node valueNode, ResolutionDartType value) {
     assert(invariant(node, !node.isIndex));
     Element setterElement = elements[node];
     Element getterElement = elements[node.selector];
     Identifier selector = node.selector;
     ResolutionDartType getter = computeAccessType(
         node, selector.source, getterElement, MemberKind.GETTER);
+    if (getter.isVoid) {
+      reportTypeWarning(node, MessageKind.VOID_EXPRESSION);
+      getter = const ResolutionDynamicType();
+    }
     ResolutionDartType setter = computeAccessType(
         node, selector.source, setterElement, MemberKind.SETTER);
     // [operator] is the type of operator+ or operator- on [target].
     ResolutionDartType operator =
         lookupMemberType(node, getter, operatorName, MemberKind.OPERATOR);
     if (operator is ResolutionFunctionType) {
       ResolutionFunctionType operatorType = operator;
       // [result] is the type of target o value.
       ResolutionDartType result = operatorType.returnType;
       ResolutionDartType operatorArgument =
@@ skipping 10 matching lines @@
   }
 
   /**
    * Checks [: base[key] o= value :] for some operator o, and returns the type
    * of the result. This method also handles increment/decrement expressions
    * like [: base[key]++ :].
    */
   ResolutionDartType checkIndexAssignmentOperator(SendSet node,
       String operatorName, Node valueNode, ResolutionDartType value) {
     assert(invariant(node, node.isIndex));
-    final ResolutionDartType base = analyze(node.receiver);
+    final ResolutionDartType base = analyzeNonVoid(node.receiver);
     final Node keyNode = node.arguments.head;
-    final ResolutionDartType key = analyze(keyNode);
+    final ResolutionDartType key = analyzeNonVoid(keyNode);
 
     // [indexGet] is the type of operator[] on [base].
     ResolutionDartType indexGet =
         lookupMemberType(node, base, '[]', MemberKind.OPERATOR);
     if (indexGet is ResolutionFunctionType) {
       ResolutionFunctionType indexGetType = indexGet;
       ResolutionDartType indexGetKey = firstType(indexGetType.parameterTypes);
       // Check base[key].
       bool validKey = checkAssignable(keyNode, key, indexGetKey);
 
@@ skipping 40 matching lines @@
   }
 
   visitSendSet(SendSet node) {
     Element element = elements[node];
     Identifier selector = node.selector;
     final name = node.assignmentOperator.source;
     if (identical(name, '=') || identical(name, '??=')) {
       // e1 = value
       if (node.isIndex) {
         // base[key] = value
-        final ResolutionDartType base = analyze(node.receiver);
+        final ResolutionDartType base = analyzeNonVoid(node.receiver);
         final Node keyNode = node.arguments.head;
-        final ResolutionDartType key = analyze(keyNode);
+        final ResolutionDartType key = analyzeNonVoid(keyNode);
         final Node valueNode = node.arguments.tail.head;
-        final ResolutionDartType value = analyze(valueNode);
+        final ResolutionDartType value = analyzeNonVoid(valueNode);
         ResolutionDartType indexSet =
             lookupMemberType(node, base, '[]=', MemberKind.OPERATOR);
         ResolutionDartType indexSetValue = const ResolutionDynamicType();
         if (indexSet is ResolutionFunctionType) {
           ResolutionFunctionType indexSetType = indexSet;
           ResolutionDartType indexSetKey =
               firstType(indexSetType.parameterTypes);
           checkAssignable(keyNode, key, indexSetKey);
           indexSetValue = secondType(indexSetType.parameterTypes);
           checkAssignable(node.assignmentOperator, value, indexSetValue);
@@ skipping 10 matching lines @@
           // members.
           target = computeAccessType(
               node, selector.source, element, MemberKind.GETTER,
               lookupClassMember: true);
         } else {
           // Normal assignment `target = value`.
           target = computeAccessType(
               node, selector.source, element, MemberKind.SETTER);
         }
         final Node valueNode = node.arguments.head;
-        final ResolutionDartType value = analyze(valueNode);
+        final ResolutionDartType value = analyzeNonVoid(valueNode);
         checkAssignable(node.assignmentOperator, value, target);
         return identical(name, '=')
             ? value
             : types.computeLeastUpperBound(value, target);
       }
     } else if (identical(name, '++') || identical(name, '--')) {
       // e++ or e--
       String operatorName = identical(name, '++') ? '+' : '-';
       if (node.isIndex) {
         // base[key]++, base[key]--, ++base[key], or --base[key]
@@ skipping 40 matching lines @@
           break;
         case '>>=':
           operatorName = '>>';
           break;
         default:
           reporter.internalError(node, 'Unexpected assignment operator $name.');
       }
       if (node.isIndex) {
         // base[key] o= value for some operator o.
         final Node valueNode = node.arguments.tail.head;
-        final ResolutionDartType value = analyze(valueNode);
+        final ResolutionDartType value = analyzeNonVoid(valueNode);
         return checkIndexAssignmentOperator(
             node, operatorName, valueNode, value);
       } else {
         // target o= value for some operator o.
         final Node valueNode = node.arguments.head;
-        final ResolutionDartType value = analyze(valueNode);
+        final ResolutionDartType value = analyzeNonVoid(valueNode);
         return checkAssignmentOperator(node, operatorName, valueNode, value);
       }
     }
   }
 
   ResolutionDartType visitLiteralInt(LiteralInt node) {
     return intType;
   }
 
   ResolutionDartType visitLiteralDouble(LiteralDouble node) {
     return doubleType;
   }
 
   ResolutionDartType visitLiteralBool(LiteralBool node) {
     return boolType;
   }
 
   ResolutionDartType visitLiteralString(LiteralString node) {
     return stringType;
   }
 
   ResolutionDartType visitStringJuxtaposition(StringJuxtaposition node) {
-    analyze(node.first);
-    analyze(node.second);
+    analyzeNonVoid(node.first);
+    analyzeNonVoid(node.second);
     return stringType;
   }
 
   ResolutionDartType visitLiteralNull(LiteralNull node) {
     return const ResolutionDynamicType();
   }
 
   ResolutionInterfaceType visitLiteralSymbol(LiteralSymbol node) {
     return commonElements.symbolType;
   }
@@ skipping 36 matching lines @@
     return newType;
   }
 
   ResolutionDartType visitLiteralList(LiteralList node) {
     ResolutionInterfaceType listType = elements.getType(node);
     ResolutionDartType listElementType = firstType(listType.typeArguments);
     for (Link<Node> link = node.elements.nodes;
         !link.isEmpty;
         link = link.tail) {
       Node element = link.head;
-      ResolutionDartType elementType = analyze(element);
+      ResolutionDartType elementType = analyzeNonVoid(element);
       checkAssignable(element, elementType, listElementType,
           isConst: node.isConst);
     }
     return listType;
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       analyzeUntyped(link.head, inInitializer: analyzingInitializer);
     }
@@ skipping 22 matching lines @@
     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): we want to break this exception.
+        // No return x; allowed in a void function. Even if the return type is
+        // void.
         if (expectedReturnType.isVoid &&
             !types.isAssignable(expressionType, const ResolutionVoidType())) {
           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())) {
+      // 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});
     }
   }
 
   ResolutionDartType visitThrow(Throw node) {
     // TODO(johnniwinther): Handle reachability.
-    analyze(node.expression);
+    analyzeNonVoid(node.expression);
     return const ResolutionDynamicType();
   }
 
   ResolutionDartType visitAwait(Await node) {
     ResolutionDartType expressionType = analyze(node.expression);
     if (resolution.target.supportsAsyncAwait) {
       return types.flatten(expressionType);
     } else {
       return const ResolutionDynamicType();
     }
   }
 
   visitYield(Yield node) {
-    ResolutionDartType resultType = analyze(node.expression);
+    ResolutionDartType resultType = analyzeNonVoid(node.expression);
     if (!node.hasStar) {
       if (currentAsyncMarker.isAsync) {
         ResolutionInterfaceType streamOfResultType =
             commonElements.streamType(resultType);
         resultType = streamOfResultType;
       } else {
         ResolutionInterfaceType iterableOfResultType =
             commonElements.iterableType(resultType);
         resultType = iterableOfResultType;
       }
@@ skipping 78 matching lines @@
 
   ResolutionDartType visitConditional(Conditional node) {
     Expression condition = node.condition;
     Expression thenExpression = node.thenExpression;
 
     checkCondition(condition);
 
     ResolutionDartType thenType =
         analyzeInPromotedContext(condition, thenExpression);
 
-    ResolutionDartType elseType = analyze(node.elseExpression);
+    ResolutionDartType elseType = analyzeNonVoid(node.elseExpression);
     return types.computeLeastUpperBound(thenType, elseType);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     node.visitChildren(this);
     return stringType;
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     node.visitChildren(this);
@@ skipping 18 matching lines @@
     if (declaredIdentifier != null) {
       return analyzeWithDefault(
           declaredIdentifier.type, const ResolutionDynamicType());
     } else {
       return analyze(node.declaredIdentifier);
     }
   }
 
   visitAsyncForIn(AsyncForIn node) {
     ResolutionDartType elementType = computeForInElementType(node);
-    ResolutionDartType expressionType = analyze(node.expression);
+    ResolutionDartType expressionType = analyzeNonVoid(node.expression);
     if (resolution.target.supportsAsyncAwait) {
       ResolutionInterfaceType streamOfDynamic = commonElements.streamType();
       if (!types.isAssignable(expressionType, streamOfDynamic)) {
         reportMessage(node.expression, MessageKind.NOT_ASSIGNABLE,
             {'fromType': expressionType, 'toType': streamOfDynamic},
             isHint: true);
       } else {
         ResolutionInterfaceType interfaceType =
             Types.computeInterfaceType(resolution, expressionType);
         if (interfaceType != null) {
           ResolutionInterfaceType streamType =
               interfaceType.asInstanceOf(streamOfDynamic.element);
           if (streamType != null) {
             ResolutionDartType streamElementType =
                 streamType.typeArguments.first;
-            if (!types.isAssignable(streamElementType, elementType)) {
+            if (streamElementType.isVoid) {
+              reportTypeWarning(
+                  node.expression, MessageKind.AWAIT_FORIN_VOID_GENERIC);
+            } else if (!types.isAssignable(streamElementType, elementType)) {
               reportMessage(
                   node.expression,
                   MessageKind.FORIN_NOT_ASSIGNABLE,
                   {
                     'currentType': streamElementType,
                     'expressionType': expressionType,
                     'elementType': elementType
                   },
                   isHint: true);
             }
           }
         }
       }
     }
     analyzeUntyped(node.body);
   }
 
   visitSyncForIn(SyncForIn node) {
     ResolutionDartType elementType = computeForInElementType(node);
-    ResolutionDartType expressionType = analyze(node.expression);
+    ResolutionDartType expressionType = analyzeNonVoid(node.expression);
     ResolutionDartType iteratorType = lookupMemberType(node.expression,
         expressionType, Identifiers.iterator, MemberKind.GETTER);
     ResolutionDartType currentType = lookupMemberType(
         node.expression, iteratorType, Identifiers.current, MemberKind.GETTER,
         isHint: true);
-    if (!types.isAssignable(currentType, elementType)) {
+    if (currentType.isVoid) {
+      reportTypeWarning(node.expression, MessageKind.FORIN_VOID_GENERIC);
+    } else if (!types.isAssignable(currentType, elementType)) {
       reportMessage(
           node.expression,
           MessageKind.FORIN_NOT_ASSIGNABLE,
           {
             'currentType': currentType,
             'expressionType': expressionType,
             'elementType': elementType
           },
           isHint: true);
     }
     analyzeUntyped(node.body);
   }
 
   visitLabeledStatement(LabeledStatement node) {
     analyzeUntyped(node.statement);
   }
 
   visitLiteralMap(LiteralMap node) {
     ResolutionInterfaceType mapType = elements.getType(node);
     ResolutionDartType mapKeyType = firstType(mapType.typeArguments);
     ResolutionDartType mapValueType = secondType(mapType.typeArguments);
     bool isConst = node.isConst;
     for (Link<Node> link = node.entries.nodes;
         !link.isEmpty;
         link = link.tail) {
       LiteralMapEntry entry = link.head;
-      ResolutionDartType keyType = analyze(entry.key);
+      ResolutionDartType keyType = analyzeNonVoid(entry.key);
       checkAssignable(entry.key, keyType, mapKeyType, isConst: isConst);
-      ResolutionDartType valueType = analyze(entry.value);
+      ResolutionDartType valueType = analyzeNonVoid(entry.value);
       checkAssignable(entry.value, valueType, mapValueType, isConst: isConst);
     }
     return mapType;
   }
 
   visitNamedArgument(NamedArgument node) {
     // Named arguments are visited as part of analyzing invocations of
     // unresolved methods. For instance [: foo(a: 42); :] where 'foo' is neither
     // found in the enclosing scope nor through lookup on 'this' or
     // [: x.foo(b: 42); :] where 'foo' cannot be not found through lookup on
     // the static type of 'x'.
-    return analyze(node.expression);
+    return analyzeNonVoid(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     // TODO(johnniwinther): Handle reachability based on reachability of
     // switch cases.
     // TODO(johnniwinther): Provide hint of duplicate case constants.
 
-    ResolutionDartType expressionType = analyze(node.expression);
+    ResolutionDartType expressionType = analyzeNonVoid(node.expression);
 
     // Check that all the case expressions are assignable to the expression.
     bool hasDefaultCase = false;
     for (SwitchCase switchCase in node.cases) {
       if (switchCase.isDefaultCase) {
         hasDefaultCase = true;
       }
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
-        ResolutionDartType caseType = analyze(caseMatch.expression);
+        ResolutionDartType caseType = analyzeNonVoid(caseMatch.expression);
         checkAssignable(caseMatch, expressionType, caseType);
       }
 
       analyzeUntyped(switchCase);
     }
 
     if (!hasDefaultCase && expressionType.isEnumType) {
       compiler.enqueuer.resolution.addDeferredAction(executableContext, () {
         Map<ConstantValue, FieldElement> enumValues =
             <ConstantValue, FieldElement>{};
@@ skipping 56 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }