Make support for async/await syntax optional in the frontend.

pkg/compiler/lib/src/resolution/resolution.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.resolution;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 125 matching lines @@
   }
 
   static void processAsyncMarker(Compiler compiler,
       BaseFunctionElementX element, ResolutionRegistry registry) {
     DiagnosticReporter reporter = compiler.reporter;
     Resolution resolution = compiler.resolution;
     CoreClasses coreClasses = compiler.coreClasses;
     FunctionExpression functionExpression = element.node;
     AsyncModifier asyncModifier = functionExpression.asyncModifier;
     if (asyncModifier != null) {
-      if (asyncModifier.isAsynchronous) {
-        element.asyncMarker = asyncModifier.isYielding
-            ? AsyncMarker.ASYNC_STAR
-            : AsyncMarker.ASYNC;
+      if (!compiler.backend.supportsAsyncAwait) {
+        reporter.reportErrorMessage(functionExpression.asyncModifier,
+            MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
       } else {
-        element.asyncMarker = AsyncMarker.SYNC_STAR;
-      }
-      if (element.isAbstract) {
-        reporter.reportErrorMessage(
-            asyncModifier,
-            MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
-            {'modifier': element.asyncMarker});
-      } else if (element.isConstructor) {
-        reporter.reportErrorMessage(
-            asyncModifier,
-            MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
-            {'modifier': element.asyncMarker});
-      } else {
-        if (element.isSetter) {
+        if (asyncModifier.isAsynchronous) {
+          element.asyncMarker = asyncModifier.isYielding
+              ? AsyncMarker.ASYNC_STAR
+              : AsyncMarker.ASYNC;
+        } else {
+          element.asyncMarker = AsyncMarker.SYNC_STAR;
+        }
+        if (element.isAbstract) {
           reporter.reportErrorMessage(
               asyncModifier,
-              MessageKind.ASYNC_MODIFIER_ON_SETTER,
+              MessageKind.ASYNC_MODIFIER_ON_ABSTRACT_METHOD,
               {'modifier': element.asyncMarker});
-        }
-        if (functionExpression.body.asReturn() != null &&
-            element.asyncMarker.isYielding) {
+        } else if (element.isConstructor) {
           reporter.reportErrorMessage(
               asyncModifier,
-              MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
+              MessageKind.ASYNC_MODIFIER_ON_CONSTRUCTOR,
               {'modifier': element.asyncMarker});
+        } else {
+          if (element.isSetter) {
+            reporter.reportErrorMessage(
+                asyncModifier,
+                MessageKind.ASYNC_MODIFIER_ON_SETTER,
+                {'modifier': element.asyncMarker});
+          }
+          if (functionExpression.body.asReturn() != null &&
+              element.asyncMarker.isYielding) {
+            reporter.reportErrorMessage(
+                asyncModifier,
+                MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
+                {'modifier': element.asyncMarker});
+          }
         }
-      }
-      switch (element.asyncMarker) {
-        case AsyncMarker.ASYNC:
-          registry.registerFeature(Feature.ASYNC);
-          coreClasses.futureClass.ensureResolved(resolution);
-          break;
-        case AsyncMarker.ASYNC_STAR:
-          registry.registerFeature(Feature.ASYNC_STAR);
-          coreClasses.streamClass.ensureResolved(resolution);
-          break;
-        case AsyncMarker.SYNC_STAR:
-          registry.registerFeature(Feature.SYNC_STAR);
-          coreClasses.iterableClass.ensureResolved(resolution);
-          break;
+        switch (element.asyncMarker) {
+          case AsyncMarker.ASYNC:
+            registry.registerFeature(Feature.ASYNC);
+            coreClasses.futureClass.ensureResolved(resolution);
+            break;
+          case AsyncMarker.ASYNC_STAR:
+            registry.registerFeature(Feature.ASYNC_STAR);
+            coreClasses.streamClass.ensureResolved(resolution);
+            break;
+          case AsyncMarker.SYNC_STAR:
+            registry.registerFeature(Feature.SYNC_STAR);
+            coreClasses.iterableClass.ensureResolved(resolution);
+            break;
+        }
       }
     }
   }
 
   bool _isNativeClassOrExtendsNativeClass(ClassElement classElement) {
     assert(classElement != null);
     while (classElement != null) {
       if (compiler.backend.isNative(classElement)) return true;
       classElement = classElement.superclass;
     }
@@ skipping 889 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements != null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }