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

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.
 
 library dart2js.typechecker;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 1697 matching lines @@
   }
 
   DartType visitThrow(Throw node) {
     // TODO(johnniwinther): Handle reachability.
     analyze(node.expression);
     return const DynamicType();
   }
 
   DartType visitAwait(Await node) {
     DartType expressionType = analyze(node.expression);
-    return types.flatten(expressionType);
+    if (compiler.backend.supportsAsyncAwait) {
+      return types.flatten(expressionType);
+    } else {
+      return const DynamicType();
+    }
   }
 
   DartType visitYield(Yield node) {
     DartType resultType = analyze(node.expression);
     if (!node.hasStar) {
       if (currentAsyncMarker.isAsync) {
         resultType = coreTypes.streamType(resultType);
       } else {
         resultType = coreTypes.iterableType(resultType);
       }
@@ skipping 102 matching lines @@
     if (declaredIdentifier != null) {
       return analyzeWithDefault(declaredIdentifier.type, const DynamicType());
     } else {
       return analyze(node.declaredIdentifier);
     }
   }
 
   visitAsyncForIn(AsyncForIn node) {
     DartType elementType = computeForInElementType(node);
     DartType expressionType = analyze(node.expression);
-    DartType streamOfDynamic = coreTypes.streamType();
-    if (!types.isAssignable(expressionType, streamOfDynamic)) {
-      reportMessage(node.expression, MessageKind.NOT_ASSIGNABLE,
-          {'fromType': expressionType, 'toType': streamOfDynamic},
-          isHint: true);
-    } else {
-      InterfaceType interfaceType =
-          Types.computeInterfaceType(resolution, expressionType);
-      if (interfaceType != null) {
-        InterfaceType streamType =
-            interfaceType.asInstanceOf(streamOfDynamic.element);
-        if (streamType != null) {
-          DartType streamElementType = streamType.typeArguments.first;
-          if (!types.isAssignable(streamElementType, elementType)) {
-            reportMessage(
-                node.expression,
-                MessageKind.FORIN_NOT_ASSIGNABLE,
-                {
-                  'currentType': streamElementType,
-                  'expressionType': expressionType,
-                  'elementType': elementType
-                },
-                isHint: true);
+    if (compiler.backend.supportsAsyncAwait) {
+      DartType streamOfDynamic = coreTypes.streamType();
+      if (!types.isAssignable(expressionType, streamOfDynamic)) {
+        reportMessage(node.expression, MessageKind.NOT_ASSIGNABLE,
+            {'fromType': expressionType, 'toType': streamOfDynamic},
+            isHint: true);
+      } else {
+        InterfaceType interfaceType =
+            Types.computeInterfaceType(resolution, expressionType);
+        if (interfaceType != null) {
+          InterfaceType streamType =
+              interfaceType.asInstanceOf(streamOfDynamic.element);
+          if (streamType != null) {
+            DartType streamElementType = streamType.typeArguments.first;
+            if (!types.isAssignable(streamElementType, elementType)) {
+              reportMessage(
+                  node.expression,
+                  MessageKind.FORIN_NOT_ASSIGNABLE,
+                  {
+                    'currentType': streamElementType,
+                    'expressionType': expressionType,
+                    'elementType': elementType
+                  },
+                  isHint: true);
+            }
           }
         }
       }
     }
     analyze(node.body);
     return const StatementType();
   }
 
   visitSyncForIn(SyncForIn node) {
     DartType elementType = computeForInElementType(node);
@@ skipping 136 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     reporter.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }