Serialize data for LibraryElement.getImportsFor

pkg/compiler/lib/src/serialization/modelz.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.
 
 /// Implementation of the element model used for deserialiation.
 ///
 /// These classes are created by [ElementDeserializer] triggered by the
 /// [Deserializer].
 
 library dart2js.serialization.modelz;
@@ skipping 178 matching lines @@
         return element;
       }
     }
     if (members == null) {
       return null;
     }
     bool hasId = members.containsKey(name);
     String setterName = '$name,=';
     bool hasSetterId = members.containsKey(setterName);
     Element element;
-    Element setterElement;
+    SetterElement setterElement;
     if (!hasId && !hasSetterId) {
       _lookupCache[name] = null;
       return null;
     }
     bool isAccessor = false;
     if (hasId) {
       element = members.getElement(name);
       isAccessor = element.isGetter;
     }
     if (hasSetterId) {
@@ skipping 117 matching lines @@
   }
 }
 
 class AbstractFieldElementZ extends ElementZ
     with AbstractFieldElementCommon
     implements AbstractFieldElement {
   final String name;
   final GetterElementZ getter;
   final SetterElementZ setter;
 
-  AbstractFieldElementZ(this.name, this.getter, this.setter) {
+  factory AbstractFieldElementZ(
+      String name, GetterElement getter, SetterElement setter) {
+    if (getter != null && getter.abstractField != null) {

[Harry Terkelsen, 2016/07/13 18:06:46]

if (getter?.abstractField != null)

[Johnni Winther, 2016/07/15 08:15:20]

Done.

+      return getter.abstractField;
+    } else if (setter != null && setter.abstractField != null) {
+      return setter.abstractField;
+    } else {
+      return new AbstractFieldElementZ._(name, getter, setter);
+    }
+  }
+
+  AbstractFieldElementZ._(this.name, this.getter, this.setter) {
     if (getter != null) {
       getter.abstractField = this;
       getter.setter = setter;
     }
     if (setter != null) {
       setter.abstractField = this;
       setter.getter = getter;
     }
   }
 
@@ skipping 43 matching lines @@
 class LibraryElementZ extends DeserializedElementZ
     with AnalyzableElementMixin, ContainerMixin, LibraryElementCommon
     implements LibraryElement {
   Uri _canonicalUri;
   CompilationUnitElement _entryCompilationUnit;
   Link<CompilationUnitElement> _compilationUnits;
   List<ImportElement> _imports;
   List<ExportElement> _exports;
   ListedContainer _exportsMap;
   ListedContainer _importsMap;
+  Map<Element, List<ImportElement>> _importsFor;
 
   LibraryElementZ(ObjectDecoder decoder) : super(decoder);
 
   @override
   ElementKind get kind => ElementKind.LIBRARY;
 
   @override
   Element get enclosingElement => null;
 
   @override
@@ skipping 79 matching lines @@
   }
 
   @override
   Element findExported(String elementName) {
     _ensureExports();
     return _exportsMap.lookup(elementName);
   }
 
   void _ensureImports() {
     if (_importsMap == null) {
-      _importsMap = new ListedContainer(_decoder.getElements(Key.IMPORT_SCOPE));
+      _importsMap = new ListedContainer(
+          _decoder.getElements(Key.IMPORT_SCOPE, isOptional: true));
+      _importsFor = <Element, List<ImportElement>>{};
+
+      ListDecoder importsDecoder = _decoder.getList(Key.IMPORTS_FOR);
+      for (int index = 0; index < importsDecoder.length; index++) {
+        ObjectDecoder objectDecoder = importsDecoder.getObject(index);

[Harry Terkelsen, 2016/07/13 18:06:46]

maybe ListDecoder can implement Iterable<Decoder>?

[Johnni Winther, 2016/07/15 08:15:20]

The elements are either ObjectDecoder or MapDecoder and the iterator wouldn't
know. Maybe we should split ListDecoder into a ObjectListDecoder and
MapListDecoder and have it implement Iterable. I don't think you would ever need
the mixing of element types, anyway.

+        Element key = objectDecoder.getElement(Key.ELEMENT);
+        List<ImportElement> imports =
+            objectDecoder.getElements(Key.IMPORTS, isOptional: true);
+
+        // Imports are mapped to [AbstractFieldElement] which are not serialized
+        // so we use getter (or setter if there is no getter) as the key.
+        Element importedElement = key;
+        if (key.isDeferredLoaderGetter) {
+          // Use as [importedElement].
+        } else if (key.isAccessor) {
+          AccessorElement accessor = key;
+          importedElement = accessor.abstractField;
+        }
+        _importsFor[importedElement] = imports;
+      }
     }
   }
 
   @override
   void forEachImport(f(Element element)) {
     _ensureImports();
     _importsMap.forEach(f);
   }
 
   @override
   Iterable<ImportElement> getImportsFor(Element element) {
-    // TODO(johnniwinther): Serialize this to support deferred access to
-    // serialized entities.
-    return <ImportElement>[];
+    _ensureImports();
+    return _importsFor[element] ?? const <ImportElement>[];
   }
 
   String toString() {
     return 'Zlibrary(${canonicalUri})';
   }
 
   @override
   Iterable<ExportElement> get exports {
     if (_exports == null) {
       _exports = _decoder.getElements(Key.EXPORTS, isOptional: true);
@@ skipping 1834 matching lines @@
   }
 
   @override
   Node get node => throw new UnsupportedError('${this}.node');
 
   @override
   bool get hasNode => false;
 
   String toString() => 'MetadataAnnotationZ(${constant.toDartText()})';
 }