Support serialization of the compiler backbone.

pkg/compiler/lib/src/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 241 matching lines @@
       // supertypes.
       cls.ensureResolved(compiler);
 
       void processClass(ClassElement cls) {
         if (_processedClasses.contains(cls)) return;
 
         _processedClasses.add(cls);
         recentClasses.add(cls);
         cls.ensureResolved(compiler);
         cls.implementation.forEachMember(processInstantiatedClassMember);
-        if (isResolutionQueue) {
+        if (isResolutionQueue && !cls.isSynthesized) {
           compiler.resolver.checkClass(cls);
         }
         // We only tell the backend once that [cls] was instantiated, so
         // any additional dependencies must be treated as global
         // dependencies.
         compiler.backend.registerInstantiatedClass(
             cls, this, compiler.globalDependencies);
       }
       processClass(cls);
       for (Link<DartType> supertypes = cls.allSupertypes;
@@ skipping 444 matching lines @@
    * [MirrorsUsed] pattern, as we do not have a complete picture of the world,
    * yet.
    */
   bool shouldIncludeElementDueToMirrors(Element element,
                                         {bool includedEnclosing}) {
     return includedEnclosing || compiler.backend.requiredByMirrorSystem(element);
   }
 
   bool internalAddToWorkList(Element element) {
     if (element.isErroneous) return false;
+
     assert(invariant(element, element is AnalyzableElement,
         message: 'Element $element is not analyzable.'));
     if (hasBeenResolved(element)) return false;
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(element,
           "Resolution work list is closed. Trying to add $element.");
     }
 
     compiler.world.registerUsedElement(element);
 
-    queue.add(new ResolutionWorkItem(element, itemCompilationContextCreator()));
+    ResolutionWorkItem workItem;
+    if (compiler.serialization.isDeserialized(element)) {
+      workItem = compiler.serialization.createResolutionWorkItem(
+          element, itemCompilationContextCreator());
+    } else {
+      workItem = new ResolutionWorkItem(
+          element, itemCompilationContextCreator());
+    }
+    queue.add(workItem);
 
     // Enable isolate support if we start using something from the isolate
     // library, or timers for the async library.  We exclude constant fields,
     // which are ending here because their initializing expression is compiled.
     LibraryElement library = element.library;
     if (!compiler.hasIsolateSupport &&
         (!element.isField || !element.isConst)) {
       String uri = library.canonicalUri.toString();
       if (uri == 'dart:isolate') {
         enableIsolateSupport();
@@ skipping 195 matching lines @@
   void processWorkItem(void f(WorkItem work), WorkItem work) {
     f(work);
   }
 }
 
 void removeFromSet(Map<String, Set<Element>> map, Element element) {
   Set<Element> set = map[element.name];
   if (set == null) return;
   set.remove(element);
 }