Remove StatementType

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 412 matching lines @@
     }
     return type;
   }
 
   DartType analyzeWithDefault(Node node, DartType defaultValue) {
     return node != null ? analyze(node) : defaultValue;
   }
 
   /// If [inInitializer] is true, assignment should be interpreted as write to
   /// a field and not to a setter.
-  DartType analyze(Node node, {bool inInitializer: false}) {
+  DartType analyze(Node node,
+      {bool inInitializer: false, bool mustHaveType: true}) {
     if (node == null) {
       final String error = 'Unexpected node: null';
       if (lastSeenNode != null) {
         reporter.internalError(lastSeenNode, error);
       } else {
         reporter.internalError(executableContext, error);
       }
     } else {
       lastSeenNode = node;
     }
     bool previouslyInitializer = analyzingInitializer;
     analyzingInitializer = inInitializer;
     DartType result = node.accept(this);
     analyzingInitializer = previouslyInitializer;
-    if (result == null) {
+    if (result == null && mustHaveType) {
       reporter.internalError(node, 'Type is null.');
     }
     return result;
   }
 
+  void analyzeUntyped(Node node, {bool inInitializer: false}) {
+    if (node != null) {
+      analyze(node, inInitializer: inInitializer, mustHaveType: false);
+    }
+  }
+
   void checkTypePromotion(Node node, TypePromotion typePromotion,
       {bool checkAccesses: false}) {
     VariableElement variable = typePromotion.variable;
     String variableName = variable.name;
     List<Node> potentialMutationsIn =
         elements.getPotentialMutationsIn(node, variable);
     if (!potentialMutationsIn.isEmpty) {
       DiagnosticMessage hint = reporter.createMessage(
           typePromotion.node,
           MessageKind.POTENTIAL_MUTATION,
@@ skipping 59 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].
-  DartType analyzeInPromotedContext(Node context, Node node) {
+  DartType analyzeInPromotedContext(Node context, Node node,
+      {bool mustHaveType: false}) {
     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 DartType type = analyze(node);
+    final DartType type = analyze(node, mustHaveType: mustHaveType);
 
     while (!knownForNode.isEmpty) {
       unregisterKnownTypePromotion(knownForNode.head);
       knownForNode = knownForNode.tail;
     }
 
     return type;
   }
 
   /**
@@ skipping 23 matching lines @@
   void pushCascadeType(DartType type) {
     cascadeTypes = cascadeTypes.prepend(type);
   }
 
   DartType popCascadeType() {
     DartType type = cascadeTypes.head;
     cascadeTypes = cascadeTypes.tail;
     return type;
   }
 
-  DartType visitAssert(Assert node) {
+  visitAssert(Assert node) {
     analyze(node.condition);
     if (node.hasMessage) analyze(node.message);
-    return const StatementType();
   }
 
-  DartType visitBlock(Block node) {
-    return analyze(node.statements);
+  visitBlock(Block node) {
+    analyzeUntyped(node.statements);
   }
 
   DartType visitCascade(Cascade node) {
     analyze(node.expression);
     return popCascadeType();
   }
 
   DartType visitCascadeReceiver(CascadeReceiver node) {
     DartType type = analyze(node.expression);
     pushCascadeType(type);
     return type;
   }
 
-  DartType visitDoWhile(DoWhile node) {
-    analyze(node.body);
+  visitDoWhile(DoWhile node) {
+    analyzeUntyped(node.body);
     checkCondition(node.condition);
-    return const StatementType();
   }
 
-  DartType visitExpressionStatement(ExpressionStatement node) {
+  visitExpressionStatement(ExpressionStatement node) {
     Expression expression = node.expression;
     analyze(expression);
-    return const StatementType();
   }
 
   /** Dart Programming Language Specification: 11.5.1 For Loop */
-  DartType visitFor(For node) {
+  visitFor(For node) {
     if (node.initializer != null) {
-      analyze(node.initializer);
+      analyzeUntyped(node.initializer);
     }
     if (node.condition != null) {
       checkCondition(node.condition);
     }
     if (node.update != null) {
-      analyze(node.update);
+      analyzeUntyped(node.update);
     }
-    return analyze(node.body);
+    analyzeUntyped(node.body);
   }
 
-  DartType visitFunctionDeclaration(FunctionDeclaration node) {
+  visitFunctionDeclaration(FunctionDeclaration node) {
     analyze(node.function);
-    return const StatementType();
   }
 
   DartType visitFunctionExpression(FunctionExpression node) {
     DartType type;
     DartType returnType;
     final FunctionElement element = elements.getFunctionDefinition(node);
     assert(invariant(node, element != null,
         message: 'FunctionExpression with no element'));
     if (Elements.isUnresolved(element)) return const DynamicType();
     if (element.isGenerativeConstructor) {
       type = const DynamicType();
       returnType = const VoidType();
 
       element.functionSignature.forEachParameter((ParameterElement parameter) {
         if (parameter.isInitializingFormal) {
           InitializingFormalElement fieldParameter = parameter;
           checkAssignable(parameter, parameter.type,
               fieldParameter.fieldElement.computeType(resolution));
         }
       });
       if (node.initializers != null) {
-        analyze(node.initializers, inInitializer: true);
+        analyzeUntyped(node.initializers, inInitializer: true);
       }
     } else {
       FunctionType functionType = element.computeType(resolution);
       returnType = functionType.returnType;
       type = functionType;
     }
     ExecutableElement previousExecutableContext = executableContext;
     DartType previousReturnType = expectedReturnType;
     expectedReturnType = returnType;
     AsyncMarker previousAsyncMarker = currentAsyncMarker;
 
     executableContext = element;
     currentAsyncMarker = element.asyncMarker;
-    analyze(node.body);
+    analyzeUntyped(node.body);
 
     executableContext = previousExecutableContext;
     expectedReturnType = previousReturnType;
     currentAsyncMarker = previousAsyncMarker;
     return type;
   }
 
   DartType visitIdentifier(Identifier node) {
     if (node.isThis()) {
       return thisType;
     } else if (node.isSuper()) {
       return superType;
     } else {
       TypedElement element = elements[node];
       assert(invariant(node, element != null,
           message: 'Missing element for identifier'));
       assert(invariant(
           node, element.isVariable || element.isParameter || element.isField,
           message: 'Unexpected context element ${element}'));
       return element.computeType(resolution);
     }
   }
 
-  DartType visitIf(If node) {
+  visitIf(If node) {
     Expression condition = node.condition.expression;
     Statement thenPart = node.thenPart;
 
     checkCondition(node.condition);
-    analyzeInPromotedContext(condition, thenPart);
+    analyzeInPromotedContext(condition, thenPart, mustHaveType: false);
     if (node.elsePart != null) {
-      analyze(node.elsePart);
+      analyzeUntyped(node.elsePart);
     }
-    return const StatementType();
   }
 
   void checkPrivateAccess(Node node, Element element, String name) {
     if (name != null &&
         Name.isPrivateName(name) &&
         element.library != currentLibrary) {
       reportTypeWarning(node, MessageKind.PRIVATE_ACCESS,
           {'name': name, 'libraryName': element.library.libraryOrScriptName});
     }
   }
@@ skipping 930 matching lines @@
         !link.isEmpty;
         link = link.tail) {
       Node element = link.head;
       DartType elementType = analyze(element);
       checkAssignable(element, elementType, listElementType,
           isConst: node.isConst);
     }
     return listType;
   }
 
-  DartType visitNodeList(NodeList node) {
+  visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
-      analyze(link.head, inInitializer: analyzingInitializer);
+      analyzeUntyped(link.head, inInitializer: analyzingInitializer);
     }
-    return const StatementType();
   }
 
-  DartType visitRedirectingFactoryBody(RedirectingFactoryBody node) {
+  visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     // TODO(lrn): Typecheck the body. It must refer to the constructor
     // of a subtype.
-    return const StatementType();
   }
 
-  DartType visitRethrow(Rethrow node) {
-    return const StatementType();
+  visitRethrow(Rethrow node) {
+    // Nothing to do here.
   }
 
   /** Dart Programming Language Specification: 11.10 Return */
-  DartType visitReturn(Return node) {
+  visitReturn(Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
-      return const StatementType();
+      return;
     }
 
     final Node expression = node.expression;
 
     // 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) {
       DartType expressionType = analyze(expression);
       if (executableContext.isGenerativeConstructor) {
@@ skipping 14 matching lines @@
       // `return;` is allowed.
     } else if (!types.isAssignable(expectedReturnType, const VoidType())) {
       // 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});
     }
-    return const StatementType();
   }
 
   DartType visitThrow(Throw node) {
     // TODO(johnniwinther): Handle reachability.
     analyze(node.expression);
     return const DynamicType();
   }
 
   DartType visitAwait(Await node) {
     DartType expressionType = analyze(node.expression);
@@ skipping 16 matching lines @@
       if (currentAsyncMarker.isAsync) {
         // The static type of expression must be assignable to Stream.
         checkAssignable(node, resultType, commonElements.streamType());
       } else {
         // The static type of expression must be assignable to Iterable.
         checkAssignable(node, resultType, commonElements.iterableType());
       }
     }
     // The static type of the result must be assignable to the declared type.
     checkAssignable(node, resultType, expectedReturnType);
-    return const StatementType();
   }
 
   DartType visitTypeAnnotation(TypeAnnotation node) {
     return elements.getType(node);
   }
 
   DartType analyzeVariableTypeAnnotation(VariableDefinitions node) {
     DartType type = analyzeWithDefault(node.type, const DynamicType());
     if (type.isVoid) {
       reportTypeWarning(node.type, MessageKind.VOID_VARIABLE);
       type = const DynamicType();
     }
     return type;
   }
 
   void analyzeVariableInitializer(
       Spannable spannable, DartType declaredType, Node initializer) {
     if (initializer == null) return;
 
     DartType expressionType = analyzeNonVoid(initializer);
     checkAssignable(spannable, expressionType, declaredType);
   }
 
-  DartType visitVariableDefinitions(VariableDefinitions node) {
+  visitVariableDefinitions(VariableDefinitions node) {
     DartType type = analyzeVariableTypeAnnotation(node);
     for (Link<Node> link = node.definitions.nodes;
         !link.isEmpty;
         link = link.tail) {
       Node definition = link.head;
       invariant(definition, definition is Identifier || definition is SendSet,
           message: 'expected identifier or initialization');
       if (definition is SendSet) {
         SendSet initialization = definition;
         analyzeVariableInitializer(initialization.assignmentOperator, type,
             initialization.arguments.head);
         // TODO(sigmund): explore inferring a type for `var` using the RHS (like
         // DDC does), for example:
         // if (node.type == null && node.modifiers.isVar &&
         //     !initializer.isDynamic) {
         //   var variable = elements[definition];
         //   if (variable != null) {
         //     var typePromotion = new TypePromotion(
         //         node, variable, initializer);
         //     registerKnownTypePromotion(typePromotion);
         //   }
         // }
       }
     }
-    return const StatementType();
   }
 
-  DartType visitWhile(While node) {
+  visitWhile(While node) {
     checkCondition(node.condition);
-    analyze(node.body);
-    return const StatementType();
+    analyzeUntyped(node.body);
   }
 
   DartType visitParenthesizedExpression(ParenthesizedExpression node) {
     Expression expression = node.expression;
     DartType type = analyze(expression);
     for (TypePromotion typePromotion in getShownTypePromotionsFor(expression)) {
       showTypePromotion(node, typePromotion);
     }
     return type;
   }
@@ skipping 14 matching lines @@
     node.visitChildren(this);
     return stringType;
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     node.visitChildren(this);
     return stringType;
   }
 
   visitEmptyStatement(EmptyStatement node) {
-    return const StatementType();
+    // Nothing to do here.
   }
 
   visitBreakStatement(BreakStatement node) {
-    return const StatementType();
+    // Nothing to do here.
   }
 
   visitContinueStatement(ContinueStatement node) {
-    return const StatementType();
+    // Nothing to do here.
   }
 
   DartType computeForInElementType(ForIn node) {
     VariableDefinitions declaredIdentifier =
         node.declaredIdentifier.asVariableDefinitions();
     if (declaredIdentifier != null) {
       return analyzeWithDefault(declaredIdentifier.type, const DynamicType());
     } else {
       return analyze(node.declaredIdentifier);
     }
@@ skipping 24 matching lines @@
                     'currentType': streamElementType,
                     'expressionType': expressionType,
                     'elementType': elementType
                   },
                   isHint: true);
             }
           }
         }
       }
     }
-    analyze(node.body);
-    return const StatementType();
+    analyzeUntyped(node.body);
   }
 
   visitSyncForIn(SyncForIn node) {
     DartType elementType = computeForInElementType(node);
     DartType expressionType = analyze(node.expression);
     DartType iteratorType = lookupMemberType(node.expression, expressionType,
         Identifiers.iterator, MemberKind.GETTER);
     DartType currentType = lookupMemberType(
         node.expression, iteratorType, Identifiers.current, MemberKind.GETTER,
         isHint: true);
     if (!types.isAssignable(currentType, elementType)) {
       reportMessage(
           node.expression,
           MessageKind.FORIN_NOT_ASSIGNABLE,
           {
             'currentType': currentType,
             'expressionType': expressionType,
             'elementType': elementType
           },
           isHint: true);
     }
-    analyze(node.body);
-    return const StatementType();
+    analyzeUntyped(node.body);
   }
 
   visitLabeledStatement(LabeledStatement node) {
-    return analyze(node.statement);
+    analyzeUntyped(node.statement);
   }
 
   visitLiteralMap(LiteralMap node) {
     InterfaceType mapType = elements.getType(node);
     DartType mapKeyType = firstType(mapType.typeArguments);
     DartType mapValueType = secondType(mapType.typeArguments);
     bool isConst = node.isConst;
     for (Link<Node> link = node.entries.nodes;
         !link.isEmpty;
         link = link.tail) {
@@ skipping 29 matching lines @@
         hasDefaultCase = true;
       }
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         DartType caseType = analyze(caseMatch.expression);
         checkAssignable(caseMatch, expressionType, caseType);
       }
 
-      analyze(switchCase);
+      analyzeUntyped(switchCase);
     }
 
     if (!hasDefaultCase && expressionType.isEnumType) {
       compiler.enqueuer.resolution.addDeferredAction(executableContext, () {
         Map<ConstantValue, FieldElement> enumValues =
             <ConstantValue, FieldElement>{};
         List<FieldElement> unreferencedFields = <FieldElement>[];
         EnumClassElement enumClass = expressionType.element;
         enumClass.enumValues.forEach((EnumConstantElement field) {
           // TODO(johnniwinther): Ensure that the enum constant is computed at
@@ skipping 22 matching lines @@
         }
         unreferencedFields.addAll(enumValues.values);
         if (!unreferencedFields.isEmpty) {
           reporter.reportWarningMessage(node, MessageKind.MISSING_ENUM_CASES, {
             'enumType': expressionType,
             'enumValues': unreferencedFields.map((e) => e.name).join(', ')
           });
         }
       });
     }
-
-    return const StatementType();
   }
 
   visitSwitchCase(SwitchCase node) {
-    return analyze(node.statements);
+    analyzeUntyped(node.statements);
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(johnniwinther): Use reachability information of try-block,
     // catch-blocks and finally-block to compute the whether the try statement
     // is returning.
-    analyze(node.tryBlock);
+    analyzeUntyped(node.tryBlock);
     for (CatchBlock catchBlock in node.catchBlocks) {
-      analyze(catchBlock);
+      analyzeUntyped(catchBlock);
     }
-    analyzeWithDefault(node.finallyBlock, null);
-    return const StatementType();
+    analyzeUntyped(node.finallyBlock);
   }
 
   visitCatchBlock(CatchBlock node) {
-    return analyze(node.block);
+    analyzeUntyped(node.block);
   }
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }