Support async/await in the dart2js frontend.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
@@ skipping 598 matching lines @@
                'originParameterCount': originSignature.optionalParameterCount,
                'patchParameterCount': patchSignature.optionalParameterCount});
       });
     } else {
       checkMatchingPatchParameters(origin,
                                    originSignature.optionalParameters,
                                    patchSignature.optionalParameters);
     }
   }
 
+  static void processAsyncMarker(Compiler compiler,
+                                 BaseFunctionElementX element) {
+    FunctionExpression functionExpression = element.node;
+    AsyncModifier asyncModifier = functionExpression.asyncModifier;
+    if (asyncModifier != null) {
+      if (!compiler.enableAsyncAwait) {
+        compiler.reportError(asyncModifier,
+            MessageKind.EXPERIMENTAL_ASYNC_AWAIT,
+            {'modifier': element.asyncMarker});
+      } else if (!compiler.analyzeOnly) {
+        compiler.reportError(asyncModifier,
+            MessageKind.EXPERIMENTAL_ASYNC_AWAIT,
+            {'modifier': element.asyncMarker});
+      }
+
+      if (asyncModifier.isAsynchronous) {
+        element.asyncMarker = asyncModifier.isYielding
+            ? AsyncMarker.ASYNC_STAR : AsyncMarker.ASYNC;
+      } else {
+        element.asyncMarker = AsyncMarker.SYNC_STAR;
+      }
+      if (element.isAbstract) {
+        compiler.reportError(asyncModifier,
+            MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
+            {'modifier': element.asyncMarker});
+      } else if (element.isConstructor) {
+        compiler.reportError(asyncModifier,
+            MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
+            {'modifier': element.asyncMarker});
+      } else if (functionExpression.body.asReturn() != null &&
+                 element.asyncMarker.isYielding) {
+        compiler.reportError(asyncModifier,
+            MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
+            {'modifier': element.asyncMarker});
+      }
+    }
+  }
+
   TreeElements resolveMethodElement(FunctionElementX element) {
     assert(invariant(element, element.isDeclaration));
     return compiler.withCurrentElement(element, () {
       bool isConstructor =
           identical(element.kind, ElementKind.GENERATIVE_CONSTRUCTOR);
       if (compiler.enqueuer.resolution.hasBeenResolved(element)) {
         // TODO(karlklose): Remove the check for [isConstructor]. [elememts]
         // should never be non-null, not even for constructors.
         assert(invariant(element, element.isConstructor,
             message: 'Non-constructor element $element '
@@ skipping 15 matching lines @@
             registry.registerImplicitSuperCall(target);
           }
           return registry.mapping;
         } else {
           assert(element.isDeferredLoaderGetter);
           return _ensureTreeElements(element);
         }
       }
       element.parseNode(compiler);
       element.computeType(compiler);
+      processAsyncMarker(compiler, element);
       if (element.isPatched) {
         FunctionElementX patch = element.patch;
         compiler.withCurrentElement(patch, () {
           patch.parseNode(compiler);
           patch.computeType(compiler);
         });
         checkMatchingPatchSignatures(element, patch);
         element = patch;
+        processAsyncMarker(compiler, element);
       }
       return compiler.withCurrentElement(element, () {
         FunctionExpression tree = element.node;
         if (tree.modifiers.isExternal) {
           error(tree, MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
           return null;
         }
         if (isConstructor || element.isFactoryConstructor) {
           if (tree.returnType != null) {
             error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
@@ skipping 1425 matching lines @@
   final TypeResolver typeResolver;
   /// The current enclosing element for the visited AST nodes.
   Element get enclosingElement;
   /// The current scope of the visitor.
   Scope get scope;
 
   MappingVisitor(Compiler compiler, ResolutionRegistry this.registry)
       : typeResolver = new TypeResolver(compiler),
         super(compiler);
 
+  AsyncMarker get currentAsyncMarker => AsyncMarker.SYNC;
+
   /// Add [element] to the current scope and check for duplicate definitions.
   void addToScope(Element element) {
     Element existing = scope.add(element);
     if (existing != element) {
       reportDuplicateDefinition(element.name, element, existing);
     }
   }
 
+  void checkLocalDefinitionName(Node node, Element element) {
+    if (currentAsyncMarker != AsyncMarker.SYNC) {
+      if (element.name == 'yield' ||
+          element.name == 'async' ||
+          element.name == 'await') {
+        compiler.reportError(
+            node, MessageKind.ASYNC_KEYWORD_AS_IDENTIFIER,
+            {'keyword': element.name,
+             'modifier': currentAsyncMarker});
+      }
+    }
+  }
+
   /// Register [node] as the definition of [element].
   void defineLocalVariable(Node node, LocalVariableElement element) {
     invariant(node, element != null);
+    checkLocalDefinitionName(node, element);
     registry.defineElement(node, element);
   }
 
   void reportDuplicateDefinition(String name,
                                  Spannable definition,
                                  Spannable existing) {
     compiler.reportError(definition,
         MessageKind.DUPLICATE_DEFINITION, {'name': name});
     compiler.reportInfo(existing,
         MessageKind.EXISTING_DEFINITION, {'name': name});
@@ skipping 88 matching lines @@
           ? Scope.buildEnclosingScope(element) : element.buildScope(),
       // The type annotations on a typedef do not imply type checks.
       // TODO(karlklose): clean this up (dartbug.com/8870).
       inCheckContext = compiler.enableTypeAssertions &&
           !element.isLibrary &&
           !element.isTypedef &&
           !element.enclosingElement.isTypedef,
       inCatchBlock = false,
       super(compiler, registry);
 
+  AsyncMarker get currentAsyncMarker {
+    if (enclosingElement is FunctionElement) {
+      FunctionElement function = enclosingElement;
+      return function.asyncMarker;
+    }
+    return AsyncMarker.SYNC;
+  }
+
   Element reportLookupErrorIfAny(Element result, Node node, String name) {
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember) {
         compiler.reportError(
             node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
         return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
                                      {'name': name},
                                      name, enclosingElement);
       } else if (result.isAmbiguous) {
         AmbiguousElement ambiguous = result;
@@ skipping 275 matching lines @@
       name = "";
     } else {
       name = node.name.asIdentifier().source;
     }
     LocalFunctionElementX function = new LocalFunctionElementX(
         name, node, ElementKind.FUNCTION, Modifiers.EMPTY,
         enclosingElement);
     function.functionSignatureCache =
         SignatureResolver.analyze(compiler, node.parameters, node.returnType,
             function, registry, createRealParameters: true);
+    ResolverTask.processAsyncMarker(compiler, function);
+    checkLocalDefinitionName(node, function);
     registry.defineFunction(node, function);
     if (doAddToScope) {
       addToScope(function);
     }
     Scope oldScope = scope; // The scope is modified by [setupFunction].
     setupFunction(node, function);
 
     Element previousEnclosingElement = enclosingElement;
     enclosingElement = function;
     // Run the body in a fresh statement scope.
@@ skipping 605 matching lines @@
         enclosingElement.isGenerativeConstructor) {
       // It is a compile-time error if a return statement of the form
       // `return e;` appears in a generative constructor.  (Dart Language
       // Specification 13.12.)
       compiler.reportError(expression,
                            MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
     }
     visit(node.expression);
   }
 
+  visitYield(Yield node) {
+    compiler.streamClass.ensureResolved(compiler);
+    compiler.iterableClass.ensureResolved(compiler);
+    visit(node.expression);
+  }
+
   visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor) {
       compiler.reportError(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       compiler.reportHint(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     ConstructorElementX constructor = enclosingElement;
     bool isConstConstructor = constructor.isConst;
@@ skipping 50 matching lines @@
     if (isSymbolConstructor) {
       registry.registerSymbolConstructor();
     }
   }
 
   visitThrow(Throw node) {
     registry.registerThrowExpression();
     visit(node.expression);
   }
 
+  visitAwait(Await node) {
+    compiler.futureClass.ensureResolved(compiler);
+    visit(node.expression);
+  }
+
   visitVariableDefinitions(VariableDefinitions node) {
     DartType type;
     if (node.type != null) {
       type = resolveTypeAnnotation(node.type);
     } else {
       type = const DynamicType();
     }
     VariableList variables = new VariableList.node(node, type);
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(compiler, node, this, variables);
@@ skipping 1742 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }