Move compile-time constant registrations to the backend.

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;
 
 typedef ItemCompilationContext ItemCompilationContextCreator();
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
@@ skipping 86 matching lines @@
   /// 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) {
     assert(invariant(element, element.isDeclaration));
-    if (element.isForeign(compiler)) return;
     internalAddToWorkList(element);
   }
 
   /**
    * Adds [element] to the work list if it has not already been processed.
    */
   void internalAddToWorkList(Element element);
 
   void registerInstantiatedType(InterfaceType type, TreeElements elements) {
     task.measure(() {
@@ skipping 489 matching lines @@
     if (owner == null) {
       owner = element;
     }
     return resolvedElements[owner.declaration];
   }
 
   void internalAddToWorkList(Element element) {
     if (getCachedElements(element) != null) return;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
-                                          "Resolution work list is closed.");
+          "Resolution work list is closed. Trying to add $element.");
     }
     compiler.world.registerUsedElement(element);
 
     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();
@@ skipping 46 matching lines @@
     compiler.enabledNoSuchMethod = true;
     compiler.backend.enableNoSuchMethod(this);
   }
 
   /**
    * Adds an action to the post-processing queue.
    *
    * The action is performed as part of the post-processing immediately after
    * the resolution queue has been closed. As a consequence, [action] must not
    * add elements to the resolution queue.
+   *
+   * The queue is processed in FIFO order.
    */
   void addPostProcessAction(Element element, PostProcessAction action) {
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
-                                          "Resolution work list is closed.");
+          "Resolution work list is closed. "
+          "Trying to add post process action for $element");
     }
     postQueue.add(new PostProcessTask(element, action));
   }
 
   void forEachPostProcessTask(f(PostProcessTask work)) {
     while (!postQueue.isEmpty) {
       f(postQueue.removeFirst());
     }
   }
 
@@ skipping 14 matching lines @@
 
   CodegenEnqueuer(Compiler compiler,
                   ItemCompilationContext itemCompilationContextCreator())
       : super('codegen enqueuer', compiler, itemCompilationContextCreator),
         queue = new Queue<CodegenWorkItem>();
 
   bool isProcessed(Element member) =>
       member.isAbstract(compiler) || generatedCode.containsKey(member);
 
   void internalAddToWorkList(Element element) {
+    // Don't generate code for foreign elements.
+    if (element.isForeign(compiler)) return;
+
     // Codegen inlines field initializers, so it does not need to add
     // individual fields in the work list.
     if (element.isField() && element.isInstanceMember()) return;
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
-                                          "Codegen work list is closed.");
+          "Codegen work list is closed. Trying to add $element");
     }
     CodegenWorkItem workItem = new CodegenWorkItem(
         element, itemCompilationContextCreator());
     queue.add(workItem);
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${generatedCode.length} methods.');
   }
 }