Add IR nodes needed for deferred loading.

pkg/kernel/lib/ast.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 file.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 161 matching lines @@
   ///
   /// Classes of an external library are loaded at one of the [ClassLevel]s
   /// other than [ClassLevel.Body].  Members in an external library have no
   /// body, but have their typed interface present.
   ///
   /// If the libary is non-external, then its classes are at [ClassLevel.Body]
   /// and all members are loaded.
   bool isExternal;
 
   String name;
+  final List<DeferredImport> deferredImports;
   final List<Class> classes;
   final List<Procedure> procedures;
   final List<Field> fields;
 
   Library(this.importUri,
       {this.name,
       this.isExternal: false,
+      List<DeferredImport> imports,
       List<Class> classes,
       List<Procedure> procedures,
       List<Field> fields})
-      : this.classes = classes ?? <Class>[],
+      : this.deferredImports = imports ?? <DeferredImport>[],
+        this.classes = classes ?? <Class>[],
         this.procedures = procedures ?? <Procedure>[],
         this.fields = fields ?? <Field>[] {
     setParents(this.classes, this);
     setParents(this.procedures, this);
     setParents(this.fields, this);
   }
 
   /// Returns the top-level fields and procedures defined in this library.
   ///
   /// This getter is for convenience, not efficiency.  Consider manually
@@ skipping 38 matching lines @@
 
   /// Returns a possibly synthesized name for this library, consistent with
   /// the names across all [toString] calls.
   String toString() => debugLibraryName(this);
 
   Location _getLocationInEnclosingFile(int offset) {
     return enclosingProgram.getLocation(fileUri, offset);
   }
 }
 
+/// An import of form: `import <url> deferred as <name>;`.
+class DeferredImport extends TreeNode {
+  Library importedLibrary;
+  String name;
+
+  DeferredImport(this.importedLibrary, this.name);
+
+  Library get enclosingLibrary => parent;
+
+  accept(TreeVisitor v) => v.visitDeferredImport(this);
+
+  visitChildren(Visitor v) {}
+
+  transformChildren(Transformer v) {}
+}
+
 /// The degree to which the contents of a class have been loaded into memory.
 ///
 /// Each level imply the requirements of the previous ones.
 enum ClassLevel {
   /// Temporary loading level for internal use by IR producers.  Consumers of
   /// kernel code should not expect to see classes at this level.
   Temporary,
 
   /// The class may be used as a type, and it may contain members that are
   /// referenced from this build unit.
@@ skipping 2166 matching lines @@
       variable = variable.accept(v);
       variable?.parent = this;
     }
     if (body != null) {
       body = body.accept(v);
       body?.parent = this;
     }
   }
 }
 
+/// Attempt to load the library referred to by a deferred import.
+///
+/// This instruction is concerned with:
+/// - keeping track whether the deferred import is marked as 'loaded'
+/// - keeping track of whether the library code has already been downloaded
+/// - actually downloading and linking the library
+///
+/// Should return a future.  The value in this future will be the same value
+/// seen by callers of `loadLibrary` functions.
+///
+/// On backends that link the entire program eagerly, this instruction needs
+/// to mark the deferred import as 'loaded' and return a future.
+class LoadLibrary extends Expression {
+  /// Reference to a deferred import in the enclosing library.
+  DeferredImport import;
+
+  LoadLibrary(this.import);
+
+  DartType getStaticType(TypeEnvironment types) {
+    return types.futureType(const DynamicType());
+  }
+
+  accept(ExpressionVisitor v) => v.visitLoadLibrary(this);
+
+  visitChildren(Visitor v) {}
+  transformChildren(Transformer v) {}
+}
+
+/// Checks that the given deferred import has been marked as 'loaded'.
+class CheckLibraryIsLoaded extends Expression {
+  /// Reference to a deferred import in the enclosing library.
+  DeferredImport import;
+
+  CheckLibraryIsLoaded(this.import);
+
+  DartType getStaticType(TypeEnvironment types) {
+    return types.objectType;
+  }
+
+  accept(ExpressionVisitor v) => v.visitCheckLibraryIsLoaded(this);
+
+  visitChildren(Visitor v) {}
+  transformChildren(Transformer v) {}
+}
+
 // ------------------------------------------------------------------------
 //                              STATEMENTS
 // ------------------------------------------------------------------------
 
 abstract class Statement extends TreeNode {
   accept(StatementVisitor v);
 }
 
 /// A statement with a compile-time error.
 ///
@@ skipping 1219 matching lines @@
     }
   }
 }
 
 class Source {
   final List<int> lineStarts;
   final String source;
 
   Source(this.lineStarts, this.source);
 }