Add import dependencies to Kernel libraries and use them to resynthesize ImportElement(s) in Analyz…

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 5484 matching lines @@
    * The unlinked representation of the import in the summary.
    */
   final UnlinkedImport _unlinkedImport;
 
   /**
    * The index of the dependency in the `imports` list.
    */
   final int _linkedDependency;
 
   /**
+   * The kernel of the element.
+   */
+  final kernel.LibraryDependency _kernel;
+
+  /**
    * The offset of the prefix of this import in the file that contains the this
    * import directive, or `-1` if this import is synthetic.
    */
   int _prefixOffset = 0;
 
   /**
    * 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;
 
   /**
    * 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,
+        _kernel = null,
         super(null, offset);
 
   /**
+   * Initialize using the given kernel.
+   */
+  ImportElementImpl.forKernel(LibraryElementImpl enclosingLibrary, this._kernel)
+      : _unlinkedImport = null,
+        _linkedDependency = null,
+        super.forSerialized(enclosingLibrary);
+
+  /**
    * Initialize using the given serialized information.
    */
   ImportElementImpl.forSerialized(this._unlinkedImport, this._linkedDependency,
       LibraryElementImpl enclosingLibrary)
-      : super.forSerialized(enclosingLibrary);
+      : _kernel = null,
+        super.forSerialized(enclosingLibrary);
 
   @override
   List<NamespaceCombinator> get combinators {
     if (_unlinkedImport != null && _combinators == null) {
       _combinators = _buildCombinators(_unlinkedImport.combinators);
     }
     return _combinators ?? const <NamespaceCombinator>[];
   }
 
   void set combinators(List<NamespaceCombinator> combinators) {
     _assertNotResynthesized(_unlinkedImport);
     _combinators = combinators;
   }
 
   /**
    * Set whether this import is for a deferred library.
    */
   void set deferred(bool isDeferred) {
     _assertNotResynthesized(_unlinkedImport);
     setModifier(Modifier.DEFERRED, isDeferred);
   }
 
   @override
   String get identifier => "${importedLibrary.identifier}@$nameOffset";
 
   @override
   LibraryElement get importedLibrary {
+    if (_kernel != null) {
+      if (_importedLibrary == null) {
+        Uri importedUri = _kernel.targetLibrary.importUri;
+        String importedUriStr = importedUri.toString();
+        LibraryElementImpl library = enclosingElement as LibraryElementImpl;
+        _importedLibrary = library._kernelContext.getLibrary(importedUriStr);
+      }
+    }
     if (_linkedDependency != null) {
       if (_importedLibrary == null) {
         LibraryElementImpl library = enclosingElement as LibraryElementImpl;
         if (_linkedDependency == 0) {
           _importedLibrary = library;
         } else {
           _importedLibrary = library.resynthesizerContext
               .buildImportedLibrary(_linkedDependency);
         }
       }
@@ skipping 125 matching lines @@
    */
   Expression getExpression(kernel.Expression expression);
 
   /**
    * Return the [InterfaceType] for the given Kernel [type], or `null` if the
    * [type] does not correspond to an [InterfaceType].
    */
   InterfaceType getInterfaceType(ElementImpl context, kernel.Supertype type);
 
   /**
+   * Return the [LibraryElement] for the given absolute [uriStr].
+   */
+  LibraryElement getLibrary(String uriStr);
+
+  /**
    * Return the [DartType] for the given Kernel [type], or `null` if the [type]
    * does not correspond to a [DartType].
    */
   DartType getType(ElementImpl context, kernel.DartType type);
 }
 
 /**
  * A concrete implementation of a [LabelElement].
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
@@ skipping 360 matching lines @@
       LibraryElement library = element.importedLibrary;
       if (library != null) {
         libraries.add(library);
       }
     }
     return libraries.toList(growable: false);
   }
 
   @override
   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>();
-        LinkedLibrary linkedLibrary = resynthesizerContext.linkedLibrary;
-        for (int i = 0; i < length; i++) {
-          int dependency = linkedLibrary.importDependencies[i];
-          ImportElementImpl importElement = new ImportElementImpl.forSerialized(
-              unlinkedImports[i], dependency, library);
-          imports.add(importElement);
+    if (_imports == null) {
+      if (_kernelContext != null) {
+        _imports = _kernelContext.library.dependencies
+            .where((k) => k.isImport)
+            .map((k) => new ImportElementImpl.forKernel(this, k))
+            .toList(growable: false);
+      }
+      if (_unlinkedDefiningUnit != null) {
+        List<UnlinkedImport> unlinkedImports = _unlinkedDefiningUnit.imports;
+        int length = unlinkedImports.length;
+        if (length != 0) {
+          List<ImportElement> imports = new List<ImportElement>();
+          LinkedLibrary linkedLibrary = resynthesizerContext.linkedLibrary;
+          for (int i = 0; i < length; i++) {
+            int dependency = linkedLibrary.importDependencies[i];
+            ImportElementImpl importElement =
+                new ImportElementImpl.forSerialized(
+                    unlinkedImports[i], dependency, library);
+            imports.add(importElement);
+          }
+          _imports = imports;
+        } else {
+          _imports = const <ImportElement>[];
         }
-        _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) {
@@ skipping 3173 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }