Include TypeEnvironment into KernelResult.

pkg/front_end/lib/src/incremental/kernel_driver.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 
+import 'package:front_end/compiler_options.dart';
 import 'package:front_end/file_system.dart';
-import 'package:front_end/compiler_options.dart';
 import 'package:front_end/src/base/api_signature.dart';
+import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/base/processed_options.dart';
-import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/fasta/compiler_context.dart';
 import 'package:front_end/src/fasta/dill/dill_library_builder.dart';
 import 'package:front_end/src/fasta/dill/dill_target.dart';
 import 'package:front_end/src/fasta/kernel/kernel_target.dart';
 import 'package:front_end/src/fasta/kernel/utils.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/uri_translator.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/file_state.dart';
 import 'package:kernel/binary/ast_from_binary.dart';
+import 'package:kernel/core_types.dart';
 import 'package:kernel/kernel.dart' hide Source;
+import 'package:kernel/src/incremental_class_hierarchy.dart';
 import 'package:kernel/target/targets.dart' show Target;
+import 'package:kernel/type_environment.dart';
 import 'package:meta/meta.dart';
 
 /// This function is invoked for each newly discovered file, and the returned
 /// [Future] is awaited before reading the file content.
 typedef Future<Null> KernelDriverFileAddedFn(Uri uri);
 
 /// This class computes [KernelResult]s for Dart files.
 ///
 /// Let the "current file state" represent a map from file URI to the file
 /// contents most recently read from that file. When the driver needs to
@@ skipping 104 matching lines @@
       List<LibraryCycleResult> results = [];
       _testView.compiledCycles.clear();
       await _logger.runAsync('Compute results for cycles', () async {
         for (LibraryCycle cycle in cycles) {
           LibraryCycleResult result =
               await _compileCycle(nameRoot, dillTarget, cycle);
           results.add(result);
         }
       });
 
-      return new KernelResult(nameRoot, results);
+      TypeEnvironment types = _buildTypeEnvironment(nameRoot, results);
+
+      return new KernelResult(nameRoot, types, results);
     });
   }
 
-  Future<T> runWithFrontEndContext<T>(String msg, Future<T> f()) async {
-    var options = new CompilerOptions()
-      ..target = _target
-      // Note: we do not report error on the console because the driver is an
-      // ongoing background service that shouldn't polute stdout.
-      // TODO(scheglov,sigmund): add an error handler to forward errors to
-      // analyzer driver and incremental kernel generator.
-      ..reportMessages = false;
-    return await CompilerContext.runWithOptions(
-        new ProcessedOptions(options), (_) => _logger.runAsync(msg, f));
-  }
-
   /// The file with the given [uri] might have changed - updated, added, or
   /// removed. Or not, we don't know. Or it might have, but then changed back.
   ///
   /// The [uri] must be absolute and normalized file URI.
   ///
   /// Schedules the file contents for the [uri] to be read into the current
   /// file state prior the next invocation of [getKernel] returns the result.
   ///
   /// Invocation of this method will not prevent a [Future] returned from
   /// [getKernel] from completing with a result, but the result is not
   /// guaranteed to be consistent with the new current file state after this
   /// [invalidate] invocation.
   void invalidate(Uri uri) {
     _invalidatedFiles.add(uri);
   }
 
+  Future<T> runWithFrontEndContext<T>(String msg, Future<T> f()) async {
+    var options = new CompilerOptions()
+      ..target = _target
+      // Note: we do not report error on the console because the driver is an
+      // ongoing background service that shouldn't polute stdout.
+      // TODO(scheglov,sigmund): add an error handler to forward errors to
+      // analyzer driver and incremental kernel generator.
+      ..reportMessages = false;
+    return await CompilerContext.runWithOptions(
+        new ProcessedOptions(options), (_) => _logger.runAsync(msg, f));
+  }
+
+  /// Return the [TypeEnvironment] that corresponds to the [results].
+  /// All the libraries for [CoreTypes] are expected to be in the first result.
+  TypeEnvironment _buildTypeEnvironment(
+      CanonicalName nameRoot, List<LibraryCycleResult> results) {
+    var coreLibraries = results.first.kernelLibraries;
+    var program = new Program(nameRoot: nameRoot, libraries: coreLibraries);
+    return new TypeEnvironment(
+        new CoreTypes(program), new IncrementalClassHierarchy());
+  }
+
   /// Ensure that [dillTarget] includes the [cycle] libraries.  It already
   /// contains all the libraries that sorted before the given [cycle] in
   /// topological order.  Return the result with the cycle libraries.
   Future<LibraryCycleResult> _compileCycle(
       CanonicalName nameRoot, DillTarget dillTarget, LibraryCycle cycle) async {
     return _logger.runAsync('Compile cycle $cycle', () async {
       String signature = _getCycleSignature(cycle);
 
       _logger.writeln('Signature: $signature.');
       var kernelKey = '$signature.kernel';
@@ skipping 152 matching lines @@
           await file.refresh();
         }
       }
     });
   }
 }
 
 /// The result of compiling of a single file.
 class KernelResult {
   final CanonicalName nameRoot;
+  final TypeEnvironment types;
   final List<LibraryCycleResult> results;
 
-  KernelResult(this.nameRoot, this.results);
+  KernelResult(this.nameRoot, this.types, this.results);
 }
 
 /// Compilation result for a library cycle.
 class LibraryCycleResult {
   final LibraryCycle cycle;
 
   /// The signature of the result.
   ///
   /// It is based on the full content of the libraries in the [cycle], and
   /// either API signatures of the transitive dependencies (usually), or
   /// the full content of them (in the [cycle] has a library with a mixin
   /// application).
   final String signature;
 
   /// Kernel libraries for libraries in the [cycle].  Bodies of dependencies
   /// are not included, but but references to those dependencies are included.
   final List<Library> kernelLibraries;
 
   LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }
 
 @visibleForTesting
 class _TestView {
   /// The list of [LibraryCycle]s compiled for the last delta.
   /// It does not include libraries which were read from the cache.
   final List<LibraryCycle> compiledCycles = [];
 }