Support serialization of the compiler backbone.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.
 
 library elements.modelx;
 
 import 'common.dart';
 import 'elements.dart';
 import '../constants/expressions.dart';
 import '../constants/constructors.dart';
@@ skipping 633 matching lines @@
         field.getter = accessor;
       } else {
         field.setter = accessor;
       }
       add(field, listener);
     }
   }
 }
 
 class CompilationUnitElementX extends ElementX
+    with CompilationUnitElementCommon
     implements CompilationUnitElement {
   final Script script;
   PartOf partTag;
   Link<Element> localMembers = const Link<Element>();
 
   CompilationUnitElementX(Script script, LibraryElementX library)
     : this.script = script,
       super(script.name,
             ElementKind.COMPILATION_UNIT,
             library) {
@@ skipping 46 matching lines @@
       listener.reportWarning(library,
           MessageKind.MISSING_LIBRARY_NAME,
           {'libraryName': actualName});
       listener.reportInfo(tag.name,
           MessageKind.THIS_IS_THE_PART_OF_TAG);
     }
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
-  int compareTo(CompilationUnitElement other) {
-    if (this == other) return 0;
-    return '${script.readableUri}'.compareTo('${other.script.readableUri}');
-  }
-
   Element get analyzableElement => library;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitCompilationUnitElement(this, arg);
   }
 }
 
 class Importers {
   Map<Element, Link<Import>> importers = new Map<Element, Link<Import>>();
 
@@ skipping 327 matching lines @@
 
   /**
    * Returns the library name, which is either the name given in the library tag
    * or the empty string if there is no library tag.
    */
   String getLibraryName() {
     if (libraryTag == null) return '';
     return libraryTag.name.toString();
   }
 
-  /**
-   * Returns the library name (as defined by the library tag) or for script
-   * (which have no library tag) the script file name. The latter case is used
-   * to private 'library name' for scripts to use for instance in dartdoc.
-   *
-   * Note: the returned filename will still be escaped ("a%20b.dart" instead of
-   * "a b.dart").
-   */
-  String getLibraryOrScriptName() {
-    if (libraryTag != null) {
-      return libraryTag.name.toString();
-    } else {
-      // Use the file name as script name.
-      String path = canonicalUri.path;
-      return path.substring(path.lastIndexOf('/') + 1);
-    }
-  }
-
   Scope buildScope() => new LibraryScope(this);
 
   String toString() {
     if (origin != null) {
       return 'patch library(${canonicalUri})';
     } else if (patch != null) {
       return 'origin library(${canonicalUri})';
     } else {
       return 'library(${canonicalUri})';
     }
   }
 
-  int compareTo(LibraryElement other) {
-    if (this == other) return 0;
-    return getLibraryOrScriptName().compareTo(other.getLibraryOrScriptName());
-  }
-
   accept(ElementVisitor visitor, arg) {
     return visitor.visitLibraryElement(this, arg);
   }
 
   // TODO(johnniwinther): Remove these when issue 18630 is fixed.
   LibraryElementX get patch => super.patch;
   LibraryElementX get origin => super.origin;
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
@@ skipping 1050 matching lines @@
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     definingConstructor.computeType(compiler);
     functionSignatureCache = definingConstructor.functionSignature;
     typeCache = definingConstructor.type;
     return functionSignatureCache;
   }
 
   accept(ElementVisitor visitor, arg) {
-    return visitor.visitFunctionElement(this, arg);
+    return visitor.visitConstructorElement(this, arg);
   }
 }
 
 abstract class TypeDeclarationElementX<T extends GenericType>
     implements TypeDeclarationElement {
   /**
    * The `this type` for this type declaration.
    *
    * The type of [:this:] is the generic type based on this element in which
    * the type arguments are the declared type variables. For instance,
@@ skipping 60 matching lines @@
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
    * variables are not set until [element] has been resolved.
    */
   List<DartType> createTypeVariables(NodeList parameters) {
     if (parameters == null) return const <DartType>[];
 
     // Create types and elements for type variable.
     Link<Node> nodes = parameters.nodes;
     List<DartType> arguments =
-        new List.generate(nodes.slowLength(), (_) {
+        new List.generate(nodes.slowLength(), (int index) {
       TypeVariable node = nodes.head;
       String variableName = node.name.source;
       nodes = nodes.tail;
       TypeVariableElementX variableElement =
-          new TypeVariableElementX(variableName, this, node);
+          new TypeVariableElementX(variableName, this, index, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.typeCache = variableType;
       return variableType;
     }, growable: false);
     return arguments;
   }
 
   bool get isResolved => resolutionState == STATE_DONE;
 
   int get resolutionState;
@@ skipping 459 matching lines @@
     return result;
   }
 
   bool get isSwitch => statement is SwitchStatement;
 
   String toString() => 'Target:$statement';
 }
 
 class TypeVariableElementX extends ElementX with AstElementMixin
     implements TypeVariableElement {
+  final int index;
   final Node node;
   TypeVariableType typeCache;
   DartType boundCache;
 
-  TypeVariableElementX(String name, TypeDeclarationElement enclosing, this.node)
+  TypeVariableElementX(String name,
+                       TypeDeclarationElement enclosing,
+                       this.index,
+                       this.node)
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeDeclarationElement get typeDeclaration => enclosingElement;
 
   TypeVariableType computeType(compiler) => type;
 
   TypeVariableType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been set on $this."));
     return typeCache;
@@ skipping 137 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }