Add ImportElement and ExportElement

pkg/compiler/lib/src/serialization/element_serialization.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.
 
 library dart2js.serialization.elements;
 
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/source_span.dart' show
@@ skipping 21 matching lines @@
   STATIC_FUNCTION,
   STATIC_GETTER,
   STATIC_SETTER,
   INSTANCE_FUNCTION,
   INSTANCE_GETTER,
   INSTANCE_SETTER,
   TYPEDEF,
   TYPEVARIABLE,
   PARAMETER,
   INITIALIZING_FORMAL,
+  IMPORT,
+  EXPORT,
+  PREFIX,
 }
 
 /// Set of serializers used to serialize different kinds of elements by
 /// encoding into them into [ObjectEncoder]s.
 ///
 /// This class is called from the [Serializer] when an [Element] needs
 /// serialization. The [ObjectEncoder] ensures that any [Element], [DartType],
 /// and [ConstantExpression] that the serialized [Element] depends upon are also
 /// serialized.
 const List<ElementSerializer> ELEMENT_SERIALIZERS = const [
     const LibrarySerializer(),
     const CompilationUnitSerializer(),
     const ClassSerializer(),
     const ConstructorSerializer(),
     const FieldSerializer(),
     const FunctionSerializer(),
     const TypedefSerializer(),
     const TypeVariableSerializer(),
     const ParameterSerializer(),
+    const ImportSerializer(),
+    const ExportSerializer(),
+    const PrefixSerializer(),
 ];
 
 /// Interface for a function that can serialize a set of element kinds.
 abstract class ElementSerializer {
   /// Returns the [SerializedElementKind] for [element] if this serializer
   /// supports serialization of [element] or `null` otherwise.
   SerializedElementKind getSerializedKind(Element element);
 
   /// Serializes [element] into the [encoder] using the [kind] computed
   /// by [getSerializedKind].
@@ skipping 72 matching lines @@
       return SerializedElementKind.LIBRARY;
     }
     return null;
   }
 
   void serialize(LibraryElement element,
                  ObjectEncoder encoder,
                  SerializedElementKind kind) {
     encoder.setUri(
         Key.CANONICAL_URI, element.canonicalUri, element.canonicalUri);
-    encoder.setString(Key.LIBRARY_NAME, element.getLibraryName());
+    encoder.setString(Key.LIBRARY_NAME, element.libraryName);
     SerializerUtil.serializeMembers(element, encoder);
     encoder.setElement(Key.COMPILATION_UNIT, element.entryCompilationUnit);
     encoder.setElements(
         Key.COMPILATION_UNITS, element.compilationUnits.toList());
-    ListEncoder tags = encoder.createList(Key.TAGS);
+    encoder.setElements(Key.IMPORTS, element.imports);
+    encoder.setElements(Key.EXPORTS, element.exports);
 
-    for (LibraryTag tag in element.tags) {
-      if (tag is Import) {
-        ObjectEncoder importTag = tags.createObject();
-        importTag.setString(Key.KIND, 'import');
-        importTag.setElement(Key.LIBRARY, element.getLibraryFromTag(tag));
-      } else if (tag is Export) {
-        ObjectEncoder exportTag = tags.createObject();
-        exportTag.setString(Key.KIND, 'export');
-        exportTag.setElement(Key.LIBRARY, element.getLibraryFromTag(tag));
-      }
-    }
+    List<Element> importedElements = <Element>[];
+    element.forEachImport(SerializerUtil.flattenElements(importedElements));
+    encoder.setElements(Key.IMPORT_SCOPE, importedElements);
 
-    List<Element> imports = <Element>[];
-    element.forEachImport(SerializerUtil.flattenElements(imports));
-    encoder.setElements(Key.IMPORTS, imports);
+    List<Element> exportedElements = <Element>[];
+    element.forEachExport(SerializerUtil.flattenElements(exportedElements));
+    encoder.setElements(Key.EXPORT_SCOPE, exportedElements);
 
-    List<Element> exports = <Element>[];
-    element.forEachExport(SerializerUtil.flattenElements(exports));
-    encoder.setElements(Key.EXPORTS, exports);
   }
 }
 
 class CompilationUnitSerializer implements ElementSerializer {
   const CompilationUnitSerializer();
 
   SerializedElementKind getSerializedKind(Element element) {
     if (element.isCompilationUnit) {
       return SerializedElementKind.COMPILATION_UNIT;
     }
@@ skipping 229 matching lines @@
     if (element.isOptional) {
       encoder.setConstant(Key.CONSTANT, element.constant);
     }
     if (element.isInitializingFormal) {
       InitializingFormalElement initializingFormal = element;
       encoder.setElement(Key.FIELD, initializingFormal.fieldElement);
     }
   }
 }
 
+class ImportSerializer implements ElementSerializer {
+  const ImportSerializer();
+
+  SerializedElementKind getSerializedKind(Element element) {
+    if (element.isImport) {
+      return SerializedElementKind.IMPORT;
+    }
+    return null;
+  }
+
+  void serialize(ImportElement element,
+                 ObjectEncoder encoder,
+                 SerializedElementKind kind) {
+    encoder.setElement(Key.LIBRARY, element.library);
+    encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
+    encoder.setElement(Key.LIBRARY_DEPENDENCY, element.importedLibrary);
+    if (element.prefix != null) {
+      encoder.setElement(Key.PREFIX, element.prefix);
+    }
+    encoder.setBool(Key.IS_DEFERRED, element.isDeferred);
+    // TODO(johnniwinther): What is the base for the URI?
+    encoder.setUri(Key.URI, element.uri, element.uri);
+  }
+}
+
+class ExportSerializer implements ElementSerializer {
+  const ExportSerializer();
+
+  SerializedElementKind getSerializedKind(Element element) {
+    if (element.isExport) {
+      return SerializedElementKind.EXPORT;
+    }
+    return null;
+  }
+
+  void serialize(ExportElement element,
+                 ObjectEncoder encoder,
+                 SerializedElementKind kind) {
+    encoder.setElement(Key.LIBRARY, element.library);
+    encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
+    encoder.setElement(Key.LIBRARY_DEPENDENCY, element.exportedLibrary);
+    // TODO(johnniwinther): What is the base for the URI?
+    encoder.setUri(Key.URI, element.uri, element.uri);
+  }
+}
+
+class PrefixSerializer implements ElementSerializer {
+  const PrefixSerializer();
+
+  SerializedElementKind getSerializedKind(Element element) {
+    if (element.isPrefix) {
+      return SerializedElementKind.PREFIX;
+    }
+    return null;
+  }
+
+  void serialize(PrefixElement element,
+                 ObjectEncoder encoder,
+                 SerializedElementKind kind) {
+    encoder.setString(Key.NAME, element.name);
+    encoder.setElement(Key.LIBRARY, element.library);
+    encoder.setElement(Key.COMPILATION_UNIT, element.compilationUnit);
+    if (element.deferredImport != null) {
+      encoder.setElement(Key.IMPORT, element.deferredImport);
+    }
+    encoder.setBool(Key.IS_DEFERRED, element.isDeferred);
+  }
+}
+
 /// Utility class for deserializing [Element]s.
 ///
 /// This is used by the [Deserializer].
 class ElementDeserializer {
 
   /// Deserializes an [Element] from an [ObjectDecoder].
   ///
   /// The class is called from the [Deserializer] when an [Element]
   /// needs deserialization. The [ObjectDecoder] ensures that any [Element],
   /// [DartType], and [ConstantExpression] that the deserialized [Element]
@@ skipping 37 matching lines @@
       case SerializedElementKind.INSTANCE_SETTER:
         return new InstanceSetterElementZ(decoder);
       case SerializedElementKind.TYPEDEF:
         return new TypedefElementZ(decoder);
       case SerializedElementKind.TYPEVARIABLE:
         return new TypeVariableElementZ(decoder);
       case SerializedElementKind.PARAMETER:
         return new ParameterElementZ(decoder);
       case SerializedElementKind.INITIALIZING_FORMAL:
         return new InitializingFormalElementZ(decoder);
+      case SerializedElementKind.IMPORT:
+        return new ImportElementZ(decoder);
+      case SerializedElementKind.EXPORT:
+        return new ExportElementZ(decoder);
+      case SerializedElementKind.PREFIX:
+        return new PrefixElementZ(decoder);
     }
     throw new UnsupportedError("Unexpected element kind '${elementKind}.");
   }
 }