Build entire program with kernel for conversion to ssa.

pkg/compiler/lib/src/kernel/kernel.dart

 // Copyright (c) 2016, 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.md file.
 
+import 'dart:async';
 import 'dart:collection' show Queue;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/checks.dart' show CheckParentPointers;
 
 import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart' show TypeConstantExpression;
 import '../dart_types.dart'
     show DartType, FunctionType, InterfaceType, TypeKind, TypeVariableType;
 import '../diagnostics/messages.dart' show MessageKind;
 import '../diagnostics/spannable.dart' show Spannable;
 import '../elements/elements.dart'
     show
         ClassElement,
         ConstructorElement,
         Element,
+        ExportElement,
         FieldElement,
         FunctionElement,
+        ImportElement,
         LibraryElement,
         MixinApplicationElement,
         TypeVariableElement;
 import '../elements/modelx.dart' show ErroneousFieldElementX;
 import '../tree/tree.dart' show FunctionExpression, Node;
 import 'kernel_visitor.dart' show IrFunction, KernelVisitor;
 
 typedef void WorkAction();
 
 class WorkItem {
@@ skipping 77 matching lines @@
       ClassElement cls = element.enclosingClass;
       if (cls != null && cls.isMixinApplication) {
         MixinApplicationElement mixinApplication = cls;
         element = mixinApplication.mixin;
       }
       irLibrary = libraryToIr(element.library);
     }
     return new ir.Name(name, irLibrary);
   }
 
+  Future<ir.Library> loadLibrary(Uri uri) async {
+    return libraryToIr(await compiler.libraryLoader.loadLibrary(uri));
+  }
+
   ir.Library libraryToIr(LibraryElement library) {
     library = library.declaration;
     return libraries.putIfAbsent(library, () {
       String name = library.hasLibraryName ? library.libraryName : null;
       ir.Library libraryNode = new ir.Library(library.canonicalUri,
           name: name, classes: null, procedures: null, fields: null);
       addWork(library, () {
         Queue<ir.Class> classes = new Queue<ir.Class>();
         Queue<ir.Member> members = new Queue<ir.Member>();
         library.implementation.forEachLocalMember((Element e) {
@@ skipping 352 matching lines @@
   void debugMessage(Spannable spannable, String message) {
     compiler.reporter
         .reportHintMessage(spannable, MessageKind.GENERIC, {'text': message});
   }
 
   void internalError(Spannable spannable, String message) {
     compiler.reporter.internalError(spannable, message);
     throw message;
   }
 
+  forEachLibraryElement(f(LibraryElement library)) {
+    return compiler.libraryLoader.libraries.forEach(f);
+  }
+
   ConstructorTarget computeEffectiveTarget(
       ConstructorElement constructor, DartType type) {
     constructor = constructor.implementation;
     Set<ConstructorElement> seen = new Set<ConstructorElement>();
     functionToIr(constructor);
     while (constructor != constructor.effectiveTarget) {
       type = constructor.computeEffectiveTargetType(type);
       if (constructor.isGenerativeConstructor) break;
       if (!seen.add(constructor)) break;
       constructor = constructor.effectiveTarget.implementation;
       if (isSyntheticError(constructor)) break;
       functionToIr(constructor);
     }
     return new ConstructorTarget(constructor, type);
   }
 
+  /// Compute all the dependencies on the library with [uri] (including the
+  /// library itself). This is useful for creating a Kernel IR `Program`.
+  List<ir.Library> libraryDependencies(Uri uri) {
+    List<ir.Library> result = <ir.Library>[];
+    Queue<LibraryElement> notProcessed = new Queue<LibraryElement>();
+    Set<LibraryElement> seen = new Set<LibraryElement>();
+    LibraryElement library = compiler.libraryLoader.lookupLibrary(uri);
+    void processLater(LibraryElement library) {
+      if (library != null) {
+        notProcessed.addLast(library);
+      }
+    }
+
+    processLater(library);
+    seen.add(library);
+    LibraryElement core =
+        compiler.libraryLoader.lookupLibrary(Uri.parse("dart:core"));
+    if (seen.add(core)) {
+      // `dart:core` is implicitly imported by most libraries, and for some
+      // reason not included in `library.imports` below.
+      processLater(core);
+    }
+    while (notProcessed.isNotEmpty) {
+      LibraryElement library = notProcessed.removeFirst();
+      ir.Library irLibrary = libraryToIr(library);
+      for (ImportElement import in library.imports) {
+        if (seen.add(import.importedLibrary)) {
+          processLater(import.importedLibrary);
+        }
+      }
+      for (ExportElement export in library.exports) {
+        if (seen.add(export.exportedLibrary)) {
+          processLater(export.exportedLibrary);
+        }
+      }
+      for (ImportElement import in library.implementation.imports) {
+        if (seen.add(import.importedLibrary)) {
+          processLater(import.importedLibrary);
+        }
+      }
+      for (ExportElement export in library.implementation.exports) {
+        if (seen.add(export.exportedLibrary)) {
+          processLater(export.exportedLibrary);
+        }
+      }
+      if (irLibrary != null) {
+        result.add(irLibrary);
+      }
+    }
+    processWorkQueue();
+    return result;
+  }
+
   /// Returns true if [element] is synthesized to recover or represent a
   /// semantic error, for example, missing, duplicated, or ambiguous elements.
   /// However, returns false for elements that have an unrecoverable syntax
   /// error. Both kinds of element will return true from [Element.isMalformed],
   /// but they must be handled differently. For example, a static call to
   /// synthetic error element should be compiled to [ir.InvalidExpression],
   /// whereas a static call to a method which has a syntax error should be
   /// compiled to a static call to the method. The method itself will have a
   /// method body that is [ir.InvalidStatement].
   bool isSyntheticError(Element element) {
@@ skipping 66 matching lines @@
 }
 
 class ConstructorTarget {
   final ConstructorElement element;
   final DartType type;
 
   ConstructorTarget(this.element, this.type);
 
   String toString() => "ConstructorTarget($element, $type)";
 }