Partial backport of analyzer async/await fixes to Java.

editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/resolver/StaticTypeAnalyzer.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.dart.engine.internal.resolver;
 
 import com.google.dart.engine.ast.AdjacentStrings;
 import com.google.dart.engine.ast.ArgumentList;
 import com.google.dart.engine.ast.AsExpression;
 import com.google.dart.engine.ast.AssignmentExpression;
 import com.google.dart.engine.ast.AstNode;
+import com.google.dart.engine.ast.AwaitExpression;
 import com.google.dart.engine.ast.BinaryExpression;
 import com.google.dart.engine.ast.BlockFunctionBody;
 import com.google.dart.engine.ast.BooleanLiteral;
 import com.google.dart.engine.ast.CascadeExpression;
 import com.google.dart.engine.ast.ConditionalExpression;
 import com.google.dart.engine.ast.DoubleLiteral;
 import com.google.dart.engine.ast.Expression;
 import com.google.dart.engine.ast.ExpressionFunctionBody;
 import com.google.dart.engine.ast.FunctionBody;
 import com.google.dart.engine.ast.FunctionDeclaration;
@@ skipping 293 matching lines @@
         Type propagatedType = computeStaticReturnType(propagatedMethodElement);
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
           recordPropagatedType(node, propagatedType);
         }
       }
     }
     return null;
   }
 
   /**
+   * The Dart Language Specification, 16.29 (Await Expressions): <blockquote>Let flatten(T) =
+   * flatten(S) if T = Future&lt;S&gt;, and T otherwise. The static type of [the expression await
+   * "e"] is flatten(T) where T is the static type of e.</blockquote>
+   */
+  @Override
+  public Void visitAwaitExpression(AwaitExpression node) {
+    Type staticExpressionType = getStaticType(node.getExpression());
+    if (staticExpressionType == null) {
+      // TODO(brianwilkerson) Determine whether this can still happen.
+      staticExpressionType = dynamicType;
+    }
+    // TODO(paulberry): We should set staticType to flatten(staticExpressionType).  But we can't
+    // implement the flatten function because the Future type isn't available in the type provider.
+    // So to avoid bogus wrnings, set it to dynamic.
+    Type staticType = dynamicType;
+    recordStaticType(node, staticType);
+    Type propagatedExpressionType = node.getExpression().getPropagatedType();
+    if (propagatedExpressionType != null) {
+      // TODO(paulberry): This should be flatten(propagatedExpressionType) for the same reasons as
+      // documented above next to the declaration of staticType.
+      Type propagatedType = dynamicType;
+      if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
+        recordPropagatedType(node, propagatedType);
+      }
+    }
+    return null;
+  }
+
+  /**
    * The Dart Language Specification, 12.20: <blockquote>The static type of a logical boolean
    * expression is {@code bool}.</blockquote>
    * <p>
    * The Dart Language Specification, 12.21:<blockquote>A bitwise expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A bitwise expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
    * <p>
    * The Dart Language Specification, 12.22: <blockquote>The static type of an equality expression
@@ skipping 1185 matching lines @@
   /**
    * Given a function expression, compute the return type of the function. The return type of
    * functions with a block body is {@code dynamicType}, with an expression body it is the type of
    * the expression.
    * 
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   private Type computeStaticReturnTypeOfFunctionExpression(FunctionExpression node) {
     FunctionBody body = node.getBody();
+    if (body.isGenerator()) {
+      if (body.isAsynchronous()) {
+        // TODO(paulberry): We should return Stream<dynamic>.  But we can't because the Stream type
+        // isn't available in the type provider.  So to avoid bogus warnings, return dynamic.
+        return typeProvider.getDynamicType();
+      } else {
+        return typeProvider.getIterableDynamicType();
+      }
+    }
+    Type type;
     if (body instanceof ExpressionFunctionBody) {
-      return getStaticType(((ExpressionFunctionBody) body).getExpression());
+      type = getStaticType(((ExpressionFunctionBody) body).getExpression());
+    } else {
+      type = dynamicType;
     }
-    return dynamicType;
+    if (body.isAsynchronous()) {
+      // TODO(paulberry): we should return Future<flatten(type)>.  But we can't because the Future
+      // type isn't available in the type provider.  So to avoid bogus warnings, return dynamic.
+      return dynamicType;
+    } else {
+      return type;
+    }
   }
 
   /**
    * If the given element name can be mapped to the name of a class defined within the given
    * library, return the type specified by the argument.
    * 
    * @param library the library in which the specified type would be defined
    * @param elementName the name of the element for which a type is being sought
    * @param nameMap an optional map used to map the element name to a type name
    * @return the type specified by the first argument in the argument list
@@ skipping 324 matching lines @@
           || operator == TokenType.TILDE_SLASH) {
         if (getStaticType(node.getRightOperand()).equals(intType)) {
           staticType = intType;
         }
       }
     }
     // default
     return staticType;
   }
 }