Fix 2 host-checked error with the enqueuer:

sdk/lib/_internal/compiler/implementation/enqueue.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 dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 92 matching lines @@
   bool get isResolutionQueue => false;
 
   /// Returns [:true:] if [member] has been processed by this enqueuer.
   bool isProcessed(Element member);
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
-  void addToWorkList(Element element, [TreeElements elements]) {
+  void addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
     if (element.isForeign(compiler)) return;
 
     if (element.isForwardingConstructor) {
-      addToWorkList(element.targetConstructor, elements);
+      addToWorkList(element.targetConstructor);
       return;
     }
 
-    if (!addElementToWorkList(element, elements)) return;
-
-    // Enable runtime type support if we discover a getter called runtimeType.
-    // We have to enable runtime type before hitting the codegen, so
-    // that constructors know whether they need to generate code for
-    // runtime type.
-    if (element.isGetter() && element.name == Compiler.RUNTIME_TYPE) {
-      compiler.enabledRuntimeType = true;
-      // TODO(ahe): Record precise dependency here.
-      compiler.backend.registerRuntimeType(compiler.globalDependencies);
-    } else if (element == compiler.functionApplyMethod) {
-      compiler.enabledFunctionApply = true;
-    } else if (element == compiler.invokeOnMethod) {
-      compiler.enabledInvokeOn = true;
-    }
-
-    nativeEnqueuer.registerElement(element);
+    internalAddToWorkList(element);
   }
 
   /**
    * Adds [element] to the work list if it has not already been processed.
-   *
-   * Returns [:true:] if the [element] should be processed.
    */
-  // TODO(johnniwinther): Change to 'Returns true if the element was added to
-  // the work list'?
-  bool addElementToWorkList(Element element, [TreeElements elements]);
+  void internalAddToWorkList(Element element);
 
   void registerInstantiatedType(InterfaceType type, TreeElements elements) {
     ClassElement cls = type.element;
     elements.registerDependency(cls);
     cls.ensureResolved(compiler);
     universe.instantiatedTypes.add(type);
     if (universe.instantiatedClasses.contains(cls)) return;
     if (!cls.isAbstract(compiler)) {
       universe.instantiatedClasses.add(cls);
     }
@@ skipping 445 matching lines @@
 
   bool get isResolutionQueue => true;
 
   bool isProcessed(Element member) => resolvedElements.containsKey(member);
 
   TreeElements getCachedElements(Element element) {
     // TODO(ngeoffray): Get rid of this check.
     if (element.enclosingElement.isClosure()) {
       closureMapping.ClosureClassElement cls = element.enclosingElement;
       element = cls.methodElement;
+    } else if (element.isGenerativeConstructorBody()) {
+      ConstructorBodyElement body = element;
+      element = body.constructor;
     }
     Element owner = element.getOutermostEnclosingMemberOrTopLevel();
     if (owner == null) {
       owner = element;
     }
     return resolvedElements[owner.declaration];
   }
 
-  /**
-   * Sets the resolved elements of [element] to [elements], or if [elements] is
-   * [:null:], to the elements found through [getCachedElements].
-   *
-   * Returns the resolved elements.
-   */
-  TreeElements ensureCachedElements(Element element, TreeElements elements) {
-    if (elements == null) {
-      elements = getCachedElements(element);
-    }
-    resolvedElements[element] = elements;
-    return elements;
-  }
-
-  bool addElementToWorkList(Element element, [TreeElements elements]) {
+  void internalAddToWorkList(Element element) {
+    if (getCachedElements(element) != null) return;
     if (queueIsClosed) {
-      if (getCachedElements(element) != null) return false;
       throw new SpannableAssertionFailure(element,
                                           "Resolution work list is closed.");
     }
-    if (elements == null) {
-      elements = getCachedElements(element);
-    }
     compiler.world.registerUsedElement(element);
 
-    if (elements == null) {
-      queue.add(
-          new ResolutionWorkItem(element, itemCompilationContextCreator()));
-    }
+    queue.add(new ResolutionWorkItem(element, itemCompilationContextCreator()));
 
     // Enable isolate support if we start using something from the
     // isolate library, or timers for the async library.
     LibraryElement library = element.getLibrary();
     if (!compiler.hasIsolateSupport()) {
       String uri = library.canonicalUri.toString();
       if (uri == 'dart:isolate') {
         enableIsolateSupport(library);
       } else if (uri == 'dart:async') {
         ClassElement cls = element.getEnclosingClass();
         if (cls != null && cls.name == const SourceString('Timer')) {
           // The [:Timer:] class uses the event queue of the isolate
           // library, so we make sure that event queue is generated.
           enableIsolateSupport(library);
         }
       }
     }
 
-    return true;
+    if (element.isGetter() && element.name == Compiler.RUNTIME_TYPE) {
+      // Enable runtime type support if we discover a getter called runtimeType.
+      // We have to enable runtime type before hitting the codegen, so
+      // that constructors know whether they need to generate code for
+      // runtime type.
+      compiler.enabledRuntimeType = true;
+      // TODO(ahe): Record precise dependency here.
+      compiler.backend.registerRuntimeType(compiler.globalDependencies);
+    } else if (element == compiler.functionApplyMethod) {
+      compiler.enabledFunctionApply = true;
+    } else if (element == compiler.invokeOnMethod) {
+      compiler.enabledInvokeOn = true;
+    }
+
+    nativeEnqueuer.registerElement(element);
   }
 
   void enableIsolateSupport(LibraryElement element) {
     compiler.isolateLibrary = element.patch;
     var startRootIsolate =
         compiler.isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE);
     addToWorkList(startRootIsolate);
     compiler.globalDependencies.registerDependency(startRootIsolate);
     addToWorkList(compiler.isolateHelperLibrary.find(
         const SourceString('_currentIsolate')));
@@ skipping 58 matching lines @@
       new Map<Element, js.Expression>();
 
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator())
       : super('codegen enqueuer', compiler, itemCompilationContextCreator),
         queue = new Queue<CodegenWorkItem>();
 
   bool isProcessed(Element member) =>
       member.isAbstract(compiler) || generatedCode.containsKey(member);
 
-  bool addElementToWorkList(Element element, [TreeElements elements]) {
+  void internalAddToWorkList(Element element) {
     // Codegen inlines field initializers, so it does not need to add
     // individual fields in the work list.
-    if (element.isField() && element.isInstanceMember()) return true;
+    if (element.isField() && element.isInstanceMember()) return;
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
                                           "Codegen work list is closed.");
     }
-    elements =
-        compiler.enqueuer.resolution.ensureCachedElements(element, elements);
-
     CodegenWorkItem workItem = new CodegenWorkItem(
-        element, elements, itemCompilationContextCreator());
+        element, itemCompilationContextCreator());
     queue.add(workItem);
-
-    return true;
   }
 
   void forEach(f(WorkItem work)) {
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }