Support serialization of the compiler backbone.

pkg/compiler/lib/src/resolution/class_hierarchy.dart

 // Copyright (c) 2015, 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 resolution;
 
 class TypeDefinitionVisitor extends MappingVisitor<DartType> {
   Scope scope;
   final TypeDeclarationElement enclosingElement;
   TypeDeclarationElement get element => enclosingElement;
@@ skipping 252 matching lines @@
     String superName = supertype.name;
     String mixinName = mixinType.name;
     MixinApplicationElementX mixinApplication = new MixinApplicationElementX(
         "${superName}+${mixinName}",
         element.compilationUnit,
         compiler.getNextFreeClassId(),
         node,
         new Modifiers.withFlags(new NodeList.empty(), Modifiers.FLAG_ABSTRACT));
     // Create synthetic type variables for the mixin application.
     List<DartType> typeVariables = <DartType>[];
+    int index = 0;
     element.typeVariables.forEach((TypeVariableType type) {

[floitsch, 2015/06/26 20:54:04]

Since this closure captures something I would slightly prefer if this was a `for
(TypeVariableType type in element.typeVariables)` loop.
But then I would change the next loop too (for consistency).

[Johnni Winther, 2015/07/03 12:13:44]

Done.

       TypeVariableElementX typeVariableElement = new TypeVariableElementX(
-          type.name, mixinApplication, type.element.node);
+          type.name, mixinApplication, index, type.element.node);
       TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
       typeVariables.add(typeVariable);
+      index++;
     });
     // Setup bounds on the synthetic type variables.
-    int index = 0;
     element.typeVariables.forEach((TypeVariableType type) {
-      TypeVariableType typeVariable = typeVariables[index++];
+      TypeVariableType typeVariable = typeVariables[type.element.index];
       TypeVariableElementX typeVariableElement = typeVariable.element;
       typeVariableElement.typeCache = typeVariable;
       typeVariableElement.boundCache =
           type.element.bound.subst(typeVariables, element.typeVariables);
     });
     // Setup this and raw type for the mixin application.
     mixinApplication.computeThisAndRawType(compiler, typeVariables);
     // Substitute in synthetic type variables in super and mixin types.
     supertype = supertype.subst(typeVariables, element.typeVariables);
     mixinType = mixinType.subst(typeVariables, element.typeVariables);
 
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     // Replace the synthetic type variables by the original type variables in
     // the returned type (which should be the type actually extended).
     InterfaceType mixinThisType = mixinApplication.thisType;
     return mixinThisType.subst(element.typeVariables,
                                mixinThisType.typeArguments);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
     if (constructor.name != '') return false;
     constructor.computeType(compiler);
     return constructor.functionSignature.parameterCount == 0;
   }
 
   FunctionElement createForwardingConstructor(ConstructorElement target,
                                               ClassElement enclosing) {
-    return new SynthesizedConstructorElementX.notForDefault(
-        target.name, target, enclosing);
+    FunctionElement constructor =
+        new SynthesizedConstructorElementX.notForDefault(
+            target.name, target, enclosing);
+    constructor.computeType(compiler);
+    return constructor;
   }
 
   void doApplyMixinTo(MixinApplicationElementX mixinApplication,
                       DartType supertype,
                       DartType mixinType) {
     Node node = mixinApplication.parseNode(compiler);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
       assert(invariant(node, compiler.compilationFailed));
@@ skipping 235 matching lines @@
 class ClassSupertypeResolver extends CommonResolverVisitor {
   Scope context;
   ClassElement classElement;
 
   ClassSupertypeResolver(Compiler compiler, ClassElement cls)
     : context = Scope.buildEnclosingScope(cls),
       this.classElement = cls,
       super(compiler);
 
   void loadSupertype(ClassElement element, Node from) {
-    compiler.resolver.loadSupertypes(element, from);
-    element.ensureResolved(compiler);
+    if (!element.isResolved) {
+      compiler.resolver.loadSupertypes(element, from);
+      element.ensureResolved(compiler);
+    }
   }
 
   void visitNodeList(NodeList node) {
     if (node != null) {
       for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
         link.head.accept(this);
       }
     }
   }
 
@@ skipping 49 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
       error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
             {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }