Implementation of async-await transformation on js ast.

pkg/compiler/lib/src/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 474 matching lines @@
       if (seen.contains(redirection)) {
         resolver.visitor.error(node, MessageKind.REDIRECTING_CONSTRUCTOR_CYCLE);
         return;
       }
       seen.add(redirection);
       redirection = resolver.visitor.resolveConstructorRedirection(redirection);
     }
   }
 
   static void processAsyncMarker(Compiler compiler,
-                                 BaseFunctionElementX element) {
+                                 BaseFunctionElementX element,
+                                 Registry registry) {
     FunctionExpression functionExpression = element.node;
     AsyncModifier asyncModifier = functionExpression.asyncModifier;
     if (asyncModifier != null) {
-      if (!compiler.enableAsyncAwait) {
-        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});
       }
+      registry.registerAsyncMarker(element);
     }
   }
 
   TreeElements resolveMethodElementImplementation(
       FunctionElement element, FunctionExpression tree) {
     return compiler.withCurrentElement(element, () {
       if (element.isExternal && tree.hasBody()) {
         compiler.reportError(element,
             MessageKind.EXTERNAL_WITH_BODY,
             {'functionName': element.name});
       }
       if (element.isConstructor) {
         if (tree.returnType != null) {
           compiler.reportError(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
         }
         if (element.isConst &&
             tree.hasBody() &&
             !tree.isRedirectingFactory) {
           compiler.reportError(tree, MessageKind.CONST_CONSTRUCTOR_HAS_BODY);
         }
       }
 
       ResolverVisitor visitor = visitorFor(element);
       ResolutionRegistry registry = visitor.registry;
       registry.defineFunction(tree, element);
       visitor.setupFunction(tree, element);
+      processAsyncMarker(compiler, element, registry);
 
       if (element.isGenerativeConstructor) {
         // Even if there is no initializer list we still have to do the
         // resolution in case there is an implicit super constructor call.
         InitializerResolver resolver = new InitializerResolver(visitor);
         FunctionElement redirection =
             resolver.resolveInitializers(element, tree);
         if (redirection != null) {
           resolveRedirectingConstructor(resolver, tree, element, redirection);
         }
@@ skipping 54 matching lines @@
             registry.registerImplicitSuperCall(target);
           }
           return registry.mapping;
         } else {
           assert(element.isDeferredLoaderGetter || element.isErroneous);
           return _ensureTreeElements(element);
         }
       } else {
         element.parseNode(compiler);
         element.computeType(compiler);
-        processAsyncMarker(compiler, element);
         FunctionElementX implementation = element;
         if (element.isExternal) {
           implementation = compiler.backend.resolveExternalFunction(element);
         }
         return resolveMethodElementImplementation(
             implementation, implementation.node);
       }
     });
   }
 
@@ skipping 1830 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);
+    ResolverTask.processAsyncMarker(compiler, function, registry);
     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;
@@ skipping 2539 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }