Add implicit dart:core import when resynthsize from Kernel.

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 5768 matching lines @@
    * The index of the dependency in the `imports` list.
    */
   final int _linkedDependency;
 
   /**
    * The kernel of the element.
    */
   final kernel.LibraryDependency _kernel;
 
   /**
+   * Whether this import is synthetic.
+   */
+  final bool _kernelSynthetic;
+
+  /**
    * 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;
 
@@ skipping 15 matching lines @@
   String _selectedUri;
 
   /**
    * 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,
+        _kernelSynthetic = false,
         super(null, offset);
 
   /**
    * Initialize using the given kernel.
    */
-  ImportElementImpl.forKernel(LibraryElementImpl enclosingLibrary, this._kernel)
+  ImportElementImpl.forKernel(LibraryElementImpl enclosingLibrary, this._kernel,
+      {bool isSynthetic: false})
       : _unlinkedImport = null,
         _linkedDependency = null,
+        _kernelSynthetic = isSynthetic,
         super.forSerialized(enclosingLibrary);
 
   /**
    * Initialize using the given serialized information.
    */
   ImportElementImpl.forSerialized(this._unlinkedImport, this._linkedDependency,
       LibraryElementImpl enclosingLibrary)
       : _kernel = null,
+        _kernelSynthetic = false,
         super.forSerialized(enclosingLibrary);
 
   @override
   List<NamespaceCombinator> get combinators {
     if (_combinators == null) {
       if (_kernel != null) {
         _combinators = _buildCombinatorsForKernel(_kernel.combinators);
       }
       if (_unlinkedImport != null) {
         _combinators = _buildCombinators(_unlinkedImport.combinators);
@@ skipping 50 matching lines @@
   @override
   bool get isDeferred {
     if (_unlinkedImport != null) {
       return _unlinkedImport.isDeferred;
     }
     return hasModifier(Modifier.DEFERRED);
   }
 
   @override
   bool get isSynthetic {
+    if (_kernel != null) {
+      return _kernelSynthetic;
+    }
     if (_unlinkedImport != null) {
       return _unlinkedImport.isImplicit;
     }
     return super.isSynthetic;
   }
 
   @override
   ElementKind get kind => ElementKind.IMPORT;
 
   @override
@@ skipping 156 matching lines @@
     } else {
       return const <NamespaceCombinator>[];
     }
   }
 }
 
 /**
  * The kernel context in which a library is resynthesized.
  */
 abstract class KernelLibraryResynthesizerContext {
+  /**
+   * The Kernel library for `dart:core`.
+   */
+  kernel.Library get coreLibrary;
+
+  /**
+   * The Kernel library being resynthesized.
+   */
   kernel.Library get library;
 
   /**
    * Return the [LibraryElement] for the given absolute [uriStr].
    */
   LibraryElement getLibrary(String uriStr);
 }
 
 /**
  * Top-level declarations of a Kernel library filtered by the unit.
@@ skipping 131 matching lines @@
   ElementKind get kind => ElementKind.LABEL;
 
   @override
   T accept<T>(ElementVisitor<T> visitor) => visitor.visitLabelElement(this);
 }
 
 /**
  * A concrete implementation of a [LibraryElement].
  */
 class LibraryElementImpl extends ElementImpl implements LibraryElement {
+  static final Uri _dartCore = Uri.parse('dart:core');
+
   /**
    * The analysis context in which this library is defined.
    */
   final AnalysisContext context;
 
   final LibraryResynthesizerContext resynthesizerContext;
 
   /**
    * The kernel context in which the library is resynthesized.
    */
@@ skipping 293 matching lines @@
         libraries.add(library);
       }
     }
     return libraries.toList(growable: false);
   }
 
   @override
   List<ImportElement> get imports {
     if (_imports == null) {
       if (_kernelContext != null) {
-        _imports = _kernelContext.library.dependencies
-            .where((k) => k.isImport)
-            .map((k) => new ImportElementImpl.forKernel(this, k))
-            .toList(growable: false);
+        var dependencies = _kernelContext.library.dependencies;
+        int numOfDependencies = dependencies.length;
+        // Compute the number of import dependencies.
+        bool hasCore = false;
+        int numOfImports = 0;
+        for (int i = 0; i < numOfDependencies; i++) {
+          kernel.LibraryDependency dependency = dependencies[i];
+          if (dependency.isImport) {
+            numOfImports++;
+            if (dependency.targetLibrary.importUri == _dartCore) {
+              hasCore = true;
+            }
+          }
+        }
+        // Create import elements.
+        var imports = new List<ImportElement>(numOfImports + (hasCore ? 0 : 1));
+        for (int i = 0; i < numOfDependencies; i++) {
+          kernel.LibraryDependency dependency = dependencies[i];
+          if (dependency.isImport) {
+            imports[i] = new ImportElementImpl.forKernel(this, dependency);
+          }
+        }
+        // If dart:core is not imported explicitly, import it implicitly.
+        if (!hasCore) {
+          imports[numOfImports] = new ImportElementImpl.forKernel(this,
+              new kernel.LibraryDependency.import(_kernelContext.coreLibrary),
+              isSynthetic: true);
+        }
+        // Set imports into the field.
+        _imports = imports;
       }
       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 =
@@ skipping 3371 matching lines @@
 
   @override
   DartObject computeConstantValue() => null;
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }