Resynthesize exports lazily.

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 3072 matching lines @@
     safelyVisitChildren(_parameters, visitor);
   }
 }
 
 /**
  * A concrete implementation of an [ExportElement].
  */
 class ExportElementImpl extends UriReferencedElementImpl
     implements ExportElement {
   /**
+   * The unlinked representation of the export in the summary.
+   */
+  final UnlinkedExportPublic _unlinkedExportPublic;
+
+  /**
+   * The unlinked representation of the export in the summary.
+   */
+  final UnlinkedExportNonPublic _unlinkedExportNonPublic;
+
+  /**
    * The library that is exported from this library by this export directive.
    */
-  LibraryElement exportedLibrary;
+  LibraryElement _exportedLibrary;
 
   /**
    * The combinators that were specified as part of the export directive in the
    * order in which they were specified.
    */
-  List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_LIST;
+  List<NamespaceCombinator> _combinators;
 
   /**
    * Initialize a newly created export element at the given [offset].
    */
-  ExportElementImpl(int offset) : super(null, offset);
+  ExportElementImpl(int offset)
+      : _unlinkedExportPublic = null,
+        _unlinkedExportNonPublic = null,
+        super(null, offset);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  ExportElementImpl.forSerialized(this._unlinkedExportPublic,
+      this._unlinkedExportNonPublic, LibraryElementImpl enclosingLibrary)
+      : super.forSerialized(enclosingLibrary);
+
+  @override
+  List<NamespaceCombinator> get combinators {
+    if (_unlinkedExportPublic != null && _combinators == null) {
+      _combinators = ImportElementImpl
+          ._buildCombinators(_unlinkedExportPublic.combinators);
+    }
+    return _combinators ?? const <NamespaceCombinator>[];
+  }
+
+  void set combinators(List<NamespaceCombinator> combinators) {
+    assert(_unlinkedExportPublic == null);
+    _combinators = combinators;
+  }
+
+  @override
+  LibraryElement get exportedLibrary {
+    if (_unlinkedExportNonPublic != null && _exportedLibrary == null) {
+      LibraryElementImpl library = enclosingElement as LibraryElementImpl;
+      _exportedLibrary = library.resynthesizerContext
+          .buildExportedLibrary(_unlinkedExportPublic.uri);
+    }
+    return _exportedLibrary;
+  }
+
+  void set exportedLibrary(LibraryElement exportedLibrary) {
+    assert(_unlinkedExportNonPublic == null);
+    _exportedLibrary = exportedLibrary;
+  }
 
   @override
   String get identifier => exportedLibrary.name;
 
   @override
   ElementKind get kind => ElementKind.EXPORT;
 
   @override
+  List<ElementAnnotation> get metadata {
+    if (_unlinkedExportNonPublic != null) {
+      if (_metadata == null) {
+        CompilationUnitElementImpl definingUnit =
+            library.definingCompilationUnit as CompilationUnitElementImpl;
+        return _metadata ??= _unlinkedExportNonPublic.annotations
+            .map((a) =>
+                definingUnit.resynthesizerContext.buildAnnotation(this, a))
+            .toList();
+      }
+    }
+    return super.metadata;
+  }
+
+  void set metadata(List<ElementAnnotation> metadata) {
+    assert(_unlinkedExportNonPublic == null);
+    super.metadata = metadata;
+  }
+
+  @override
+  int get nameOffset {
+    if (_unlinkedExportNonPublic != null) {
+      return _unlinkedExportNonPublic.offset;
+    }
+    return super.nameOffset;
+  }
+
+  @override
+  String get uri {
+    if (_unlinkedExportPublic != null) {
+      return _unlinkedExportPublic.uri;
+    }
+    return super.uri;
+  }
+
+  @override
+  void set uri(String uri) {
+    assert(_unlinkedExportPublic == null);
+    super.uri = uri;
+  }
+
+  @override
+  int get uriEnd {
+    if (_unlinkedExportNonPublic != null) {
+      return _unlinkedExportNonPublic.uriEnd;
+    }
+    return super.uriEnd;
+  }
+
+  @override
+  void set uriEnd(int uriEnd) {
+    assert(_unlinkedExportNonPublic == null);
+    super.uriEnd = uriEnd;
+  }
+
+  @override
+  int get uriOffset {
+    if (_unlinkedExportNonPublic != null) {
+      return _unlinkedExportNonPublic.uriOffset;
+    }
+    return super.uriOffset;
+  }
+
+  @override
+  void set uriOffset(int uriOffset) {
+    assert(_unlinkedExportNonPublic == null);
+    super.uriOffset = uriOffset;
+  }
+
+  @override
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("export ");
     (exportedLibrary as LibraryElementImpl).appendTo(buffer);
   }
 }
 
 /**
@@ skipping 562 matching lines @@
   /**
    * 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>[];
-      }
+      _combinators = _buildCombinators(_unlinkedImport.combinators);
     }
     return _combinators ?? const <NamespaceCombinator>[];
   }
 
   void set combinators(List<NamespaceCombinator> combinators) {
     assert(_unlinkedImport == null);
     _combinators = combinators;
   }
 
   /**
@@ skipping 164 matching lines @@
   void appendTo(StringBuffer buffer) {
     buffer.write("import ");
     (importedLibrary as LibraryElementImpl).appendTo(buffer);
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     prefix?.accept(visitor);
   }
+
+  static List<NamespaceCombinator> _buildCombinators(
+      List<UnlinkedCombinator> unlinkedCombinators) {
+    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);
+      }
+      return combinators;
+    } else {
+      return const <NamespaceCombinator>[];
+    }
+  }
 }
 
 /**
  * A concrete implementation of a [LabelElement].
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch`
    * statement.
    */
@@ skipping 76 matching lines @@
   /**
    * A list containing specifications of all of the imports defined in this
    * library.
    */
   List<ImportElement> _imports;
 
   /**
    * A list containing specifications of all of the exports defined in this
    * library.
    */
-  List<ExportElement> _exports = ExportElement.EMPTY_LIST;
+  List<ExportElement> _exports;
 
   /**
    * A list containing the strongly connected component in the import/export
    * graph in which the current library resides.  Computed on demand, null
    * if not present.  If _libraryCycle is set, then the _libraryCycle field
    * for all libraries reachable from this library in the import/export graph
    * is also set.
    */
   List<LibraryElement> _libraryCycle = null;
 
@@ skipping 126 matching lines @@
     return _entryPoint;
   }
 
   void set entryPoint(FunctionElement entryPoint) {
     _entryPoint = entryPoint;
   }
 
   @override
   List<LibraryElement> get exportedLibraries {
     HashSet<LibraryElement> libraries = new HashSet<LibraryElement>();
-    for (ExportElement element in _exports) {
+    for (ExportElement element in exports) {
       LibraryElement library = element.exportedLibrary;
       if (library != null) {
         libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
   @override
   Namespace get exportNamespace {
     if (resynthesizerContext != null) {
       _exportNamespace ??= resynthesizerContext.buildExportNamespace();
     }
     return _exportNamespace;
   }
 
   void set exportNamespace(Namespace exportNamespace) {
     _exportNamespace = exportNamespace;
   }
 
   @override
-  List<ExportElement> get exports => _exports;
+  List<ExportElement> get exports {
+    if (_unlinkedDefiningUnit != null && _exports == null) {
+      List<UnlinkedExportNonPublic> unlinkedNonPublicExports =
+          _unlinkedDefiningUnit.exports;
+      List<UnlinkedExportPublic> unlinkedPublicExports =
+          _unlinkedDefiningUnit.publicNamespace.exports;
+      assert(
+          _unlinkedDefiningUnit.exports.length == unlinkedPublicExports.length);
+      int length = unlinkedNonPublicExports.length;
+      if (length != 0) {
+        List<ExportElement> exports = new List<ExportElement>(length);
+        for (int i = 0; i < length; i++) {
+          UnlinkedExportPublic serializedExportPublic =
+              unlinkedPublicExports[i];
+          UnlinkedExportNonPublic serializedExportNonPublic =
+              unlinkedNonPublicExports[i];
+          exports[i] = new ExportElementImpl.forSerialized(
+              serializedExportPublic, serializedExportNonPublic, library);
+        }
+        _exports = exports;
+      } else {
+        _exports = const <ExportElement>[];
+      }
+    }
+    return _exports ?? const <ExportElement>[];
+  }
 
   /**
    * Set the specifications of all of the exports defined in this library to the
    * given list of [exports].
    */
   void set exports(List<ExportElement> exports) {
+    assert(_unlinkedDefiningUnit == null);
     for (ExportElement exportElement in exports) {
       (exportElement as ExportElementImpl).enclosingElement = this;
     }
     this._exports = exports;
   }
 
   @override
   bool get hasExtUri => hasModifier(Modifier.HAS_EXT_URI);
 
   /**
@@ skipping 314 matching lines @@
       if (partImpl.identifier == identifier) {
         return partImpl;
       }
     }
     for (ImportElement importElement in imports) {
       ImportElementImpl importElementImpl = importElement;
       if (importElementImpl.identifier == identifier) {
         return importElementImpl;
       }
     }
-    for (ExportElement exportElement in _exports) {
+    for (ExportElement exportElement in exports) {
       ExportElementImpl exportElementImpl = exportElement;
       if (exportElementImpl.identifier == identifier) {
         return exportElementImpl;
       }
     }
     return null;
   }
 
   @override
   List<ImportElement> getImportsWithPrefix(PrefixElement prefixElement) {
@@ skipping 90 matching lines @@
   void setResolutionCapability(
       LibraryResolutionCapability capability, bool value) {
     _resolutionCapabilities =
         BooleanArray.set(_resolutionCapabilities, capability.index, value);
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _definingCompilationUnit?.accept(visitor);
-    safelyVisitChildren(_exports, visitor);
+    safelyVisitChildren(exports, 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) {
       LibraryElement importedLibrary = importElement.importedLibrary;
       if (importedLibrary != null) {
         (importedLibrary as LibraryElementImpl)
             ._addVisibleLibraries(visibleLibraries, true);
       }
     }
     // add exported libraries
     if (includeExports) {
-      for (ExportElement exportElement in _exports) {
+      for (ExportElement exportElement in exports) {
         LibraryElement exportedLibrary = exportElement.exportedLibrary;
         if (exportedLibrary != null) {
           (exportedLibrary as LibraryElementImpl)
               ._addVisibleLibraries(visibleLibraries, true);
         }
       }
     }
   }
 
   /**
@@ skipping 64 matching lines @@
  * 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 exported [LibraryElement] for with the given [relativeUri].
+   */
+  LibraryElement buildExportedLibrary(String relativeUri);
+
+  /**
    * Return the export namespace of the library.
    */
   Namespace buildExportNamespace();
 
+  /**
+   * Return the imported [LibraryElement] for the given dependency in the
+   * linked library.
+   */
   LibraryElement buildImportedLibrary(int dependency);
 
   /**
    * Return the public namespace of the library.
    */
   Namespace buildPublicNamespace();
 
   /**
    * Find the entry point of the library.
    */
@@ skipping 1991 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }