Improve resolution/codegen separation invariant.

pkg/compiler/lib/src/compiler.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;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
 const bool REPORT_EXCESS_RESOLUTION = false;
 
 /**
  * Contains backend-specific data that is used throughout the compilation of
  * one work item.
  */
 class ItemCompilationContext {
 }
 
 abstract class WorkItem {
   final ItemCompilationContext compilationContext;
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [element] must be a declaration element.
    */
   final AstElement element;
+
   TreeElements get resolutionTree;
 
   WorkItem(this.element, this.compilationContext) {
     assert(invariant(element, element.isDeclaration));
   }
 
   void run(Compiler compiler, Enqueuer world);
 }
 
 /// [WorkItem] used exclusively by the [ResolutionEnqueuer].
@@ skipping 141 matching lines @@
 
   void registerAsyncMarker(FunctionElement element) {
     backend.registerAsyncMarker(element, world, this);
   }
 
 }
 
 /// [WorkItem] used exclusively by the [CodegenEnqueuer].
 class CodegenWorkItem extends WorkItem {
   Registry registry;
-  final TreeElements resolutionTree;
 
-  CodegenWorkItem(AstElement element,
-                  ItemCompilationContext compilationContext)
-      : this.resolutionTree = element.resolvedAst.elements,
-        super(element, compilationContext) {
-    assert(invariant(element, resolutionTree != null,
+  factory CodegenWorkItem(
+      Compiler compiler,
+      AstElement element,
+      ItemCompilationContext compilationContext) {
+    // If this assertion fails, the resolution callbacks of the backend may be
+    // missing call of form registry.registerXXX. Alternatively, the code
+    // generation could spuriously be adding dependencies on things we know we
+    // don't need.
+    assert(invariant(element,
+        compiler.enqueuer.resolution.hasBeenResolved(element),
+        message: "$element has not been resolved."));
+    assert(invariant(element, element.resolvedAst.elements != null,
         message: 'Resolution tree is null for $element in codegen work item'));
+    return new CodegenWorkItem.internal(element, compilationContext);
   }
 
+  CodegenWorkItem.internal(
+      AstElement element,
+      ItemCompilationContext compilationContext)
+      : super(element, compilationContext);
+
+  TreeElements get resolutionTree => element.resolvedAst.elements;
+
   void run(Compiler compiler, CodegenEnqueuer world) {
     if (world.isProcessed(element)) return;
 
     registry = new CodegenRegistry(compiler, resolutionTree);
     compiler.codegen(this, world);
   }
 }
 
 typedef void DeferredAction();
 
@@ skipping 2224 matching lines @@
     return futureClass.computeType(compiler).createInstantiation([elementType]);
   }
 
   @override
   InterfaceType streamType([DartType elementType = const DynamicType()]) {
     return streamClass.computeType(compiler).createInstantiation([elementType]);
   }
 }
 
 typedef void InternalErrorFunction(Spannable location, String message);