Make imports resynthesizing completely lazy.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 3574 matching lines @@
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 }
 
 /**
  * A concrete implementation of a [HideElementCombinator].
  */
 class HideElementCombinatorImpl implements HideElementCombinator {
   /**
+   * The unlinked representation of the combinator in the summary.
+   */
+  final UnlinkedCombinator _unlinkedCombinator;
+
+  /**
    * The names that are not to be made visible in the importing library even if
    * they are defined in the imported library.
    */
-  List<String> hiddenNames = StringUtilities.EMPTY_ARRAY;
+  List<String> _hiddenNames;
+
+  HideElementCombinatorImpl() : _unlinkedCombinator = null;
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  HideElementCombinatorImpl.forSerialized(this._unlinkedCombinator);
+
+  @override
+  List<String> get hiddenNames {
+    if (_unlinkedCombinator != null) {
+      _hiddenNames ??= _unlinkedCombinator.hides.toList(growable: false);
+    }
+    return _hiddenNames ?? StringUtilities.EMPTY_ARRAY;

[Paul Berry, 2016/05/23 15:43:52]

Nit: personally, I'd use `const <String>[]` here.  It's less typing and it
doesn't require the reader to do a cross reference to know what's going on.

[scheglov, 2016/05/23 15:48:42]

Done.

+  }
+
+  void set hiddenNames(List<String> hiddenNames) {
+    assert(_unlinkedCombinator == null);
+    _hiddenNames = hiddenNames;
+  }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write("show ");
     int count = hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         buffer.write(", ");
       }
@@ skipping 26 matching lines @@
 
   /**
    * The library that is imported into this library by this import directive.
    */
   LibraryElement _importedLibrary;
 
   /**
    * The combinators that were specified as part of the import directive in the
    * order in which they were specified.
    */
-  List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_LIST;
+  List<NamespaceCombinator> _combinators;
 
   /**
    * The prefix that was specified as part of the import directive, or `null` if
    * there was no prefix specified.
    */
   PrefixElement _prefix;
 
   /**
    * Initialize a newly created import element at the given [offset].
    * The offset may be `-1` if the import is synthetic.
    */
   ImportElementImpl(int offset)
       : _unlinkedImport = null,
         _linkedDependency = null,
         super(null, offset);
 
   /**
    * Initialize using the given serialized information.
    */
   ImportElementImpl.forSerialized(this._unlinkedImport, this._linkedDependency,
       LibraryElementImpl enclosingLibrary)
       : super.forSerialized(enclosingLibrary);
 
+  @override
+  List<NamespaceCombinator> get combinators {
+    if (_unlinkedImport != null && _combinators == null) {
+      List<UnlinkedCombinator> unlinkedCombinators =
+          _unlinkedImport.combinators;
+      int length = unlinkedCombinators.length;
+      if (length != 0) {
+        List<NamespaceCombinator> combinators =
+            new List<NamespaceCombinator>(length);
+        for (int i = 0; i < length; i++) {
+          UnlinkedCombinator unlinkedCombinator = unlinkedCombinators[i];
+          combinators[i] = unlinkedCombinator.shows.isNotEmpty
+              ? new ShowElementCombinatorImpl.forSerialized(unlinkedCombinator)
+              : new HideElementCombinatorImpl.forSerialized(unlinkedCombinator);
+        }
+        _combinators = combinators;
+      } else {
+        _combinators = const <NamespaceCombinator>[];
+      }
+    }
+    return _combinators ?? const <NamespaceCombinator>[];
+  }
+
+  void set combinators(List<NamespaceCombinator> combinators) {
+    assert(_unlinkedImport == null);
+    _combinators = combinators;
+  }
+
   /**
    * Set whether this import is for a deferred library.
    */
   void set deferred(bool isDeferred) {
     assert(_unlinkedImport == null);
     setModifier(Modifier.DEFERRED, isDeferred);
   }
 
   @override
   String get identifier => "${importedLibrary.identifier}@$nameOffset";
@@ skipping 245 matching lines @@
   /**
    * The entry point for this library, or `null` if this library does not have
    * an entry point.
    */
   FunctionElement _entryPoint;
 
   /**
    * A list containing specifications of all of the imports defined in this
    * library.
    */
-  List<ImportElement> _imports = ImportElement.EMPTY_LIST;
+  List<ImportElement> _imports;
 
   /**
    * A list containing specifications of all of the exports defined in this
    * library.
    */
   List<ExportElement> _exports = ExportElement.EMPTY_LIST;
 
   /**
    * A list containing the strongly connected component in the import/export
    * graph in which the current library resides.  Computed on demand, null
@@ skipping 182 matching lines @@
     }
     return false;
   }
 
   @override
   String get identifier => _definingCompilationUnit.source.encoding;
 
   @override
   List<LibraryElement> get importedLibraries {
     HashSet<LibraryElement> libraries = new HashSet<LibraryElement>();
-    for (ImportElement element in _imports) {
+    for (ImportElement element in imports) {
       LibraryElement library = element.importedLibrary;
       if (library != null) {
         libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
   @override
-  List<ImportElement> get imports => _imports;
+  List<ImportElement> get imports {
+    if (_unlinkedDefiningUnit != null && _imports == null) {
+      List<UnlinkedImport> unlinkedImports = _unlinkedDefiningUnit.imports;
+      int length = unlinkedImports.length;
+      if (length != 0) {
+        List<ImportElement> imports = new List<ImportElement>(length);
+        LinkedLibrary linkedLibrary = resynthesizerContext.linkedLibrary;
+        for (int i = 0; i < length; i++) {
+          imports[i] = new ImportElementImpl.forSerialized(
+              unlinkedImports[i], linkedLibrary.importDependencies[i], library);
+        }
+        _imports = imports;
+      } else {
+        _imports = const <ImportElement>[];
+      }
+    }
+    return _imports ?? ImportElement.EMPTY_LIST;
+  }
 
   /**
    * Set the specifications of all of the imports defined in this library to the
    * given list of [imports].
    */
   void set imports(List<ImportElement> imports) {
+    assert(_unlinkedDefiningUnit == null);
     for (ImportElement importElement in imports) {
       (importElement as ImportElementImpl).enclosingElement = this;
       PrefixElementImpl prefix = importElement.prefix as PrefixElementImpl;
       if (prefix != null) {
         prefix.enclosingElement = this;
       }
     }
     this._imports = imports;
   }
 
@@ skipping 161 matching lines @@
       assert((compilationUnit as CompilationUnitElementImpl).librarySource ==
           source);
       (compilationUnit as CompilationUnitElementImpl).enclosingElement = this;
     }
     this._parts = parts;
   }
 
   @override
   List<PrefixElement> get prefixes {
     HashSet<PrefixElement> prefixes = new HashSet<PrefixElement>();
-    for (ImportElement element in _imports) {
+    for (ImportElement element in imports) {
       PrefixElement prefix = element.prefix;
       if (prefix != null) {
         prefixes.add(prefix);
       }
     }
     return new List.from(prefixes);
   }
 
   @override
   Namespace get publicNamespace {
@@ skipping 52 matching lines @@
     CompilationUnitElementImpl unitImpl = _definingCompilationUnit;
     if (unitImpl.identifier == identifier) {
       return unitImpl;
     }
     for (CompilationUnitElement part in _parts) {
       CompilationUnitElementImpl partImpl = part;
       if (partImpl.identifier == identifier) {
         return partImpl;
       }
     }
-    for (ImportElement importElement in _imports) {
+    for (ImportElement importElement in imports) {
       ImportElementImpl importElementImpl = importElement;
       if (importElementImpl.identifier == identifier) {
         return importElementImpl;
       }
     }
     for (ExportElement exportElement in _exports) {
       ExportElementImpl exportElementImpl = exportElement;
       if (exportElementImpl.identifier == identifier) {
         return exportElementImpl;
       }
     }
     return null;
   }
 
   @override
   List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) {
-    int count = _imports.length;
+    var imports = this.imports;
+    int count = imports.length;
     List<ImportElement> importList = new List<ImportElement>();
     for (int i = 0; i < count; i++) {
-      if (identical(_imports[i].prefix, prefixElement)) {
-        importList.add(_imports[i]);
+      if (identical(imports[i].prefix, prefixElement)) {
+        importList.add(imports[i]);
       }
     }
     return importList;
   }
 
   @override
   ClassElement getType(String className) {
     ClassElement type = _definingCompilationUnit.getType(className);
     if (type != null) {
       return type;
@@ skipping 65 matching lines @@
   bool isUpToDate(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
     return _safeIsUpToDate(this, timeStamp, visitedLibraries);
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _definingCompilationUnit?.accept(visitor);
     safelyVisitChildren(_exports, visitor);
-    safelyVisitChildren(_imports, visitor);
+    safelyVisitChildren(imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
   /**
    * Recursively fills set of visible libraries for
    * [getVisibleElementsLibraries].
    */
   void _addVisibleLibraries(
       Set<LibraryElement> visibleLibraries, bool includeExports) {
     // maybe already processed
     if (!visibleLibraries.add(this)) {
       return;
     }
     // add imported libraries
-    for (ImportElement importElement in _imports) {
+    for (ImportElement importElement in imports) {
       LibraryElement importedLibrary = importElement.importedLibrary;
       if (importedLibrary != null) {
         (importedLibrary as LibraryElementImpl)
             ._addVisibleLibraries(visibleLibraries, true);
       }
     }
     // add exported libraries
     if (includeExports) {
       for (ExportElement exportElement in _exports) {
         LibraryElement exportedLibrary = exportElement.exportedLibrary;
@@ skipping 42 matching lines @@
     }
     return true;
   }
 }
 
 /**
  * The context in which the library is resynthesized.
  */
 abstract class LibraryResynthesizerContext {
   /**
+   * Return the [LinkedLibrary] that corresponds to the library being
+   * resynthesized.
+   */
+  LinkedLibrary get linkedLibrary;
+
+  /**
    * Return the export namespace of the library.
    */
   Namespace buildExportNamespace();
 
   LibraryElement buildImportedLibrary(int dependency);
 
   /**
    * Return the public namespace of the library.
    */
   Namespace buildPublicNamespace();
@@ skipping 1393 matching lines @@
   DartType resolveTypeRef(
       EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false, bool instantiateToBoundsAllowed: true});
 }
 
 /**
  * A concrete implementation of a [ShowElementCombinator].
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
   /**
+   * The unlinked representation of the combinator in the summary.
+   */
+  final UnlinkedCombinator _unlinkedCombinator;
+
+  /**
    * The names that are to be made visible in the importing library if they are
    * defined in the imported library.
    */
-  List<String> shownNames = StringUtilities.EMPTY_ARRAY;
+  List<String> _shownNames;
 
   /**
    * The offset of the character immediately following the last character of
    * this node.
    */
-  int end = -1;
+  int _end = -1;
 
   /**
    * The offset of the 'show' keyword of this element.
    */
-  int offset = 0;
+  int _offset = 0;
+
+  ShowElementCombinatorImpl() : _unlinkedCombinator = null;
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  ShowElementCombinatorImpl.forSerialized(this._unlinkedCombinator);
+
+  @override
+  int get end {
+    if (_unlinkedCombinator != null) {
+      return _unlinkedCombinator.end;
+    }
+    return _end;
+  }
+
+  void set end(int end) {
+    assert(_unlinkedCombinator == null);
+    _end = end;
+  }
+
+  @override
+  int get offset {
+    if (_unlinkedCombinator != null) {
+      return _unlinkedCombinator.offset;
+    }
+    return _offset;
+  }
+
+  void set offset(int offset) {
+    assert(_unlinkedCombinator == null);
+    _offset = offset;
+  }
+
+  @override
+  List<String> get shownNames {
+    if (_unlinkedCombinator != null) {
+      _shownNames ??= _unlinkedCombinator.shows.toList(growable: false);
+    }
+    return _shownNames ?? StringUtilities.EMPTY_ARRAY;
+  }
+
+  void set shownNames(List<String> shownNames) {
+    assert(_unlinkedCombinator == null);
+    _shownNames = shownNames;
+  }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     buffer.write("show ");
     int count = shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         buffer.write(", ");
       }
@@ skipping 516 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }