dart2js: Don't zone-register callbacks in async functions for every await.

pkg/compiler/lib/src/js_backend/backend.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 js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 217 matching lines @@
   static final Uri DART_FOREIGN_HELPER =
       new Uri(scheme: 'dart', path: '_foreign_helper');
   static final Uri DART_JS_MIRRORS =
       new Uri(scheme: 'dart', path: '_js_mirrors');
   static final Uri DART_JS_NAMES =
       new Uri(scheme: 'dart', path: '_js_names');
   static final Uri DART_EMBEDDED_NAMES =
       new Uri(scheme: 'dart', path: '_js_embedded_names');
   static final Uri DART_ISOLATE_HELPER =
       new Uri(scheme: 'dart', path: '_isolate_helper');
-  static final Uri DART_HTML =
-      new Uri(scheme: 'dart', path: 'html');
+  static final Uri DART_ASYNC = new Uri(scheme: 'dart', path: 'async');
+  static final Uri DART_HTML = new Uri(scheme: 'dart', path: 'html');
 
   static const String INVOKE_ON = '_getCachedInvocation';
   static const String START_ROOT_ISOLATE = 'startRootIsolate';
 
 
   String get patchVersion => emitter.patchVersion;
 
   bool get supportsReflection => emitter.emitter.supportsReflection;
 
   final Annotations annotations;
@@ skipping 16 matching lines @@
   /**
    * The generated code as a js AST for compiled methods.
    */
   Map<Element, jsAst.Expression> get generatedCode {
     return compiler.enqueuer.codegen.generatedCode;
   }
 
   FunctionInlineCache inlineCache = new FunctionInlineCache();
 
   LibraryElement jsHelperLibrary;
+  LibraryElement asyncLibrary;
   LibraryElement interceptorsLibrary;
   LibraryElement foreignLibrary;
   LibraryElement isolateHelperLibrary;
 
   ClassElement closureClass;
   ClassElement boundClosureClass;
   Element assertMethod;
   Element invokeOnMethod;
 
   ClassElement jsInterceptorClass;
@@ skipping 376 matching lines @@
   FunctionElement resolveExternalFunction(FunctionElement element) {
     if (isForeign(element)) return element;
     return patchResolverTask.measure(() {
       return patchResolverTask.resolveExternalFunction(element);
     });
   }
 
   // TODO(karlklose): Split into findHelperFunction and findHelperClass and
   // add a check that the element has the expected kind.
   Element findHelper(String name) => find(jsHelperLibrary, name);
+  Element findAsyncAwaitHelper(String name) => find(asyncLibrary, name);

[Lasse Reichstein Nielsen, 2015/08/12 09:46:55]

Seems like this just looks things up in the async library. 
It's currently only being used for async/await implementation, but the
implementation isn't bound to that.
Maybe rename to "findAsyncMember"?

[floitsch, 2015/08/12 14:53:44]

Done.

   Element findInterceptor(String name) => find(interceptorsLibrary, name);
 
   Element find(LibraryElement library, String name) {
     Element element = library.findLocal(name);
     assert(invariant(library, element != null,
         message: "Element '$name' not found in '${library.canonicalUri}'."));
     return element;
   }
 
   bool isForeign(Element element) => element.library == foreignLibrary;
@@ skipping 1161 matching lines @@
 
   Element getCreateInvocationMirror() {
     return findHelper(Compiler.CREATE_INVOCATION_MIRROR);
   }
 
   Element getCyclicThrowHelper() {
     return findHelper("throwCyclicInit");
   }
 
   Element getAsyncHelper() {
-    return findHelper("asyncHelper");
+    return findAsyncAwaitHelper("_asyncHelper");
   }
 
   Element getWrapBody() {
-    return findHelper("_wrapJsFunctionForAsync");
+    return findAsyncAwaitHelper("_wrapJsFunctionForAsync");
   }
 
   Element getYieldStar() {
-    ClassElement classElement = findHelper("IterationMarker");
+    ClassElement classElement = findAsyncAwaitHelper("_IterationMarker");
     classElement.ensureResolved(compiler);
     return classElement.lookupLocalMember("yieldStar");
   }
 
   Element getYieldSingle() {
-    ClassElement classElement = findHelper("IterationMarker");
+    ClassElement classElement = findAsyncAwaitHelper("_IterationMarker");
     classElement.ensureResolved(compiler);
     return classElement.lookupLocalMember("yieldSingle");
   }
 
   Element getSyncStarUncaughtError() {
-    ClassElement classElement = findHelper("IterationMarker");
+    ClassElement classElement = findAsyncAwaitHelper("_IterationMarker");
     classElement.ensureResolved(compiler);
     return classElement.lookupLocalMember("uncaughtError");
   }
 
   Element getAsyncStarHelper() {
-    return findHelper("asyncStarHelper");
+    return findAsyncAwaitHelper("_asyncStarHelper");
   }
 
   Element getStreamOfController() {
-    return findHelper("streamOfController");
+    return findAsyncAwaitHelper("_streamOfController");
   }
 
   Element getEndOfIteration() {
-    ClassElement classElement = findHelper("IterationMarker");
+    ClassElement classElement = findAsyncAwaitHelper("_IterationMarker");
     classElement.ensureResolved(compiler);
     return classElement.lookupLocalMember("endOfIteration");
   }
 
   Element getSyncStarIterable() {
-    ClassElement classElement = findHelper("SyncStarIterable");
+    ClassElement classElement = findAsyncAwaitHelper("_SyncStarIterable");
     classElement.ensureResolved(compiler);
     return classElement;
   }
 
   Element getSyncStarIterableConstructor() {
     ClassElement classElement = getSyncStarIterable();
     classElement.ensureResolved(compiler);
     return classElement.lookupConstructor("");
   }
 
   Element getCompleterConstructor() {
     ClassElement classElement = find(compiler.asyncLibrary, "Completer");
     classElement.ensureResolved(compiler);
     return classElement.lookupConstructor("");
   }
 
   Element getASyncStarController() {
-    ClassElement classElement = findHelper("AsyncStarStreamController");
+    ClassElement classElement =
+        findAsyncAwaitHelper("_AsyncStarStreamController");
     classElement.ensureResolved(compiler);
     return classElement;
   }
 
   Element getASyncStarControllerConstructor() {
     ClassElement classElement = getASyncStarController();
     return classElement.lookupConstructor("");
   }
 
   Element getStreamIteratorConstructor() {
@@ skipping 93 matching lines @@
       }
       return true;
     }
     return false;
   }
 
   void onLibraryCreated(LibraryElement library) {
     Uri uri = library.canonicalUri;
     if (uri == DART_JS_HELPER) {
       jsHelperLibrary = library;
+    } else if (uri == DART_ASYNC) {
+      asyncLibrary = library;
     } else if (uri == DART_INTERNAL) {
       internalLibrary = library;
     } else if (uri ==  DART_INTERCEPTORS) {
       interceptorsLibrary = library;
     } else if (uri ==  DART_FOREIGN_HELPER) {
       foreignLibrary = library;
     } else if (uri == DART_ISOLATE_HELPER) {
       isolateHelperLibrary = library;
     }
   }
@@ skipping 1044 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }