Typecheck return with respect to async.

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.
 
 part of dart2js;
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
   void check(TreeElements elements) {
     AstElement element = elements.analyzedElement;
+    if (element.isTypedef) return;
+
     compiler.withCurrentElement(element, () {
       measure(() {
         Node tree = element.node;
         TypeCheckerVisitor visitor =
             new TypeCheckerVisitor(compiler, elements, compiler.types);
         if (element.isField) {
           visitor.analyzingInitializer = true;
         }
         tree.accept(visitor);
       });
@@ skipping 31 matching lines @@
   /// Returns [: true :] if the element can be access as an invocation.
   bool isCallable(Compiler compiler) {
     if (element != null && element.isAbstractField) {
       AbstractFieldElement abstractFieldElement = element;
       if (abstractFieldElement.getter == null) {
         // Setters cannot be invoked as function invocations.
         return false;
       }
     }
     return compiler.types.isAssignable(
-        computeType(compiler), compiler.functionClass.computeType(compiler));
+        computeType(compiler), compiler.coreTypes.functionType);
   }
 }
 
 /// An access of a instance member.
 class MemberAccess extends ElementAccess {
   final MemberSignature member;
 
   MemberAccess(MemberSignature this.member);
 
   Element get element => member.declarations.first.element;
@@ skipping 182 matching lines @@
   final Compiler compiler;
   final TreeElements elements;
   final Types types;
 
   Node lastSeenNode;
   DartType expectedReturnType;
   AsyncMarker currentAsyncMarker = AsyncMarker.SYNC;
 
   final ClassElement currentClass;
 
+  /// The immediately enclosing field, method or constructor being analyzed.
+  ExecutableElement executableContext;
+
+  CoreTypes get coreTypes => compiler.coreTypes;
+
+  InterfaceType get intType => coreTypes.intType;
+  InterfaceType get doubleType => coreTypes.doubleType;
+  InterfaceType get boolType => coreTypes.boolType;
+  InterfaceType get stringType => coreTypes.stringType;
+
   DartType thisType;
   DartType superType;
 
   Link<DartType> cascadeTypes = const Link<DartType>();
 
   bool analyzingInitializer = false;
 
-  DartType intType;
-  DartType doubleType;
-  DartType boolType;
-  DartType stringType;
-  DartType objectType;
-  DartType listType;
-
   Map<Node, List<TypePromotion>> shownTypePromotionsMap =
       new Map<Node, List<TypePromotion>>();
 
   Map<VariableElement, Link<TypePromotion>> typePromotionsMap =
       new Map<VariableElement, Link<TypePromotion>>();
 
   Set<TypePromotion> reportedTypePromotions = new Set<TypePromotion>();
 
   void showTypePromotion(Node node, TypePromotion typePromotion) {
     List<TypePromotion> shownTypePromotions =
@@ skipping 39 matching lines @@
   }
 
   DartType getKnownType(VariableElement element) {
     TypePromotion typePromotion = getKnownTypePromotion(element);
     if (typePromotion != null) return typePromotion.type;
     return element.type;
   }
 
   TypeCheckerVisitor(this.compiler, TreeElements elements, this.types)
       : this.elements = elements,
-        currentClass = elements.analyzedElement != null
+        this.executableContext = elements.analyzedElement,
+        this.currentClass = elements.analyzedElement != null
             ? elements.analyzedElement.enclosingClass : null {
-    intType = compiler.intClass.computeType(compiler);
-    doubleType = compiler.doubleClass.computeType(compiler);
-    boolType = compiler.boolClass.computeType(compiler);
-    stringType = compiler.stringClass.computeType(compiler);
-    objectType = compiler.objectClass.computeType(compiler);
-    listType = compiler.listClass.computeType(compiler);
 
     if (currentClass != null) {
       thisType = currentClass.thisType;
       superType = currentClass.supertype;
     } else {
       // If these are used, an error should have been reported by the resolver.
       thisType = const DynamicType();
       superType = const DynamicType();
     }
   }
@@ skipping 46 matching lines @@
   }
 
   /// 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}) {
     if (node == null) {
       final String error = 'Unexpected node: null';
       if (lastSeenNode != null) {
         compiler.internalError(lastSeenNode, error);
       } else {
-        compiler.internalError(elements.analyzedElement, error);
+        compiler.internalError(executableContext, error);
       }
     } else {
       lastSeenNode = node;
     }
     bool previouslyInitializer = analyzingInitializer;
     analyzingInitializer = inInitializer;
     DartType result = node.accept(this);
     analyzingInitializer = previouslyInitializer;
     if (result == null) {
       compiler.internalError(node, 'Type is null.');
@@ skipping 167 matching lines @@
   }
 
   DartType visitFunctionExpression(FunctionExpression node) {
     DartType type;
     DartType returnType;
     DartType previousType;
     final FunctionElement element = elements.getFunctionDefinition(node);
     assert(invariant(node, element != null,
                      message: 'FunctionExpression with no element'));
     if (Elements.isUnresolved(element)) return const DynamicType();
-    if (identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR) ||
-        identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR_BODY)) {
+    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(compiler));
         }
       });
       if (node.initializers != null) {
         analyze(node.initializers, inInitializer: true);
       }
     } else {
       FunctionType functionType = element.computeType(compiler);
       returnType = functionType.returnType;
       type = functionType;
     }
+    ExecutableElement previousExecutableContext = executableContext;
     DartType previousReturnType = expectedReturnType;
     expectedReturnType = returnType;
     AsyncMarker previousAsyncMarker = currentAsyncMarker;
+
+    executableContext = element;
     currentAsyncMarker = element.asyncMarker;
     analyze(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;
@@ skipping 931 matching lines @@
   DartType visitRethrow(Rethrow node) {
     return const StatementType();
   }
 
   /** Dart Programming Language Specification: 11.10 Return */
   DartType visitReturn(Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
       return const StatementType();
     }
 
-    final expression = node.expression;
-    final isVoidFunction = expectedReturnType.isVoid;
+    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) {
-      final expressionType = analyze(expression);
-      Element element = elements.analyzedElement;
-      if (element != null && element.isGenerativeConstructor) {
+      DartType expressionType = analyze(expression);
+      if (executableContext.isGenerativeConstructor) {
         // The resolver already emitted an error for this expression.
-      } else if (isVoidFunction
-          && !types.isAssignable(expressionType, const VoidType())) {
-        reportTypeWarning(expression, MessageKind.RETURN_VALUE_IN_VOID);
       } else {
-        checkAssignable(expression, expressionType, expectedReturnType);
+        if (currentAsyncMarker == AsyncMarker.ASYNC) {
+          expressionType = coreTypes.futureType(flatten(expressionType));
+        }
+        if (expectedReturnType.isVoid &&
+            !types.isAssignable(expressionType, const VoidType())) {
+          reportTypeWarning(expression, MessageKind.RETURN_VALUE_IN_VOID);
+        } else {
+          checkAssignable(expression, expressionType, expectedReturnType);
+        }
       }
 
-    // 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.
     } 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();
@@ skipping 20 matching lines @@
 
   DartType visitAwait(Await node) {
     DartType expressionType = analyze(node.expression);
     return flatten(expressionType);
   }
 
   DartType visitYield(Yield node) {
     DartType resultType = analyze(node.expression);
     if (!node.hasStar) {
       if (currentAsyncMarker.isAsync) {
-        resultType = compiler.coreTypes.streamType(resultType);
+        resultType = coreTypes.streamType(resultType);
       } else {
-        resultType = compiler.coreTypes.iterableType(resultType);
+        resultType = coreTypes.iterableType(resultType);
       }
     } else {
       if (currentAsyncMarker.isAsync) {
         // The static type of expression must be assignable to Stream.
-        checkAssignable(node, resultType, compiler.coreTypes.streamType());
+        checkAssignable(node, resultType, coreTypes.streamType());
       } else {
         // The static type of expression must be assignable to Iterable.
-        checkAssignable(node, resultType, compiler.coreTypes.iterableType());
+        checkAssignable(node, resultType, coreTypes.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);
   }
@@ skipping 36 matching lines @@
 
   DartType visitConditional(Conditional node) {
     Expression condition = node.condition;
     Expression thenExpression = node.thenExpression;
 
     checkCondition(condition);
 
     DartType thenType = analyzeInPromotedContext(condition, thenExpression);
 
     DartType elseType = analyze(node.elseExpression);
-    return compiler.types.computeLeastUpperBound(thenType, elseType);
+    return types.computeLeastUpperBound(thenType, elseType);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     node.visitChildren(this);
     return stringType;
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     node.visitChildren(this);
     return stringType;
@@ skipping 65 matching lines @@
         if (caseMatch == null) continue;
 
         DartType caseType = analyze(caseMatch.expression);
         checkAssignable(caseMatch, expressionType, caseType);
       }
 
       analyze(switchCase);
     }
 
     if (!hasDefaultCase && expressionType.isEnumType) {
-      compiler.enqueuer.resolution.addDeferredAction(
-          elements.analyzedElement, () {
+      compiler.enqueuer.resolution.addDeferredAction(executableContext, () {
         Map<ConstantValue, FieldElement> enumValues =
             <ConstantValue, FieldElement>{};
         List<FieldElement> unreferencedFields = <FieldElement>[];
         EnumClassElement enumClass = expressionType.element;
         enumClass.enumValues.forEach((FieldElement field) {
           ConstantExpression constantExpression =
               compiler.constants.getConstantForVariable(field);
           if (constantExpression == null) {
             // The field might not have been resolved.
             unreferencedFields.add(field);
@@ skipping 47 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }