Add IR nodes needed for deferred loading.

pkg/kernel/lib/binary/ast_from_binary.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.
 library kernel.ast_from_binary;
 
 import '../ast.dart';
 import 'tag.dart';
 import 'loader.dart';
 import 'dart:convert';
 import 'package:kernel/transformations/flags.dart';
@@ skipping 169 matching lines @@
     Map<String, Source> uriToSource = readUriToSource();
     importTable.length = readUInt();
     for (int i = 0; i < importTable.length; ++i) {
       importTable[i] = new Library(null);
     }
     for (int i = 0; i < importTable.length; ++i) {
       _currentLibrary = importTable[i];
       readLibrary();
     }
     var mainMethod = readMemberReference(allowNull: true);
-    return new Program(importTable, uriToSource)
-      ..mainMethod = mainMethod;
+    return new Program(importTable, uriToSource)..mainMethod = mainMethod;
   }
 
   Map<String, Source> readUriToSource() {
     readSourceUriTable();
     int length = _sourceUriTable.length;
     Map<String, Source> uriToLineStarts = <String, Source>{};
     for (int i = 0; i < length; ++i) {
       String uri = _sourceUriTable[i];
       String sourceCode = readStringEntry();
       int lineCount = readUInt();
@@ skipping 17 matching lines @@
       int tag = readByte();
       buildObject(tag, i);
     }
   }
 
   Library readLibraryReference() {
     int index = readUInt();
     return importTable[index];
   }
 
+  DeferredImport readDeferredImportReference() {
+    int index = readUInt();
+    return _currentLibrary.deferredImports[index];
+  }
+
   Class readClassReference({bool allowNull: false}) {
     int tag = readByte();
     if (tag == Tag.NullReference) {
       if (!allowNull) {
         throw 'Expected a class reference to be valid but was `null`.';
       }
       return null;
     } else {
       var library = readLibraryReference();
       int index = readUInt();
@@ skipping 46 matching lines @@
     _currentLibrary.isExternal = (flags & 0x1) != 0;
     _currentLibrary.name = readStringOrNullIfEmpty();
     _currentLibrary.importUri = readImportUri();
     debugPath.add(_currentLibrary.name ??
         _currentLibrary.importUri?.toString() ??
         'library');
 
     // TODO(jensj): We currently save (almost the same) uri twice.
     _currentLibrary.fileUri = readUriReference();
 
+    _readDeferredImports(_currentLibrary);
     _fillLazilyLoadedList(_currentLibrary.classes, (int tag, int index) {
       readClass(loader.getClassReference(_currentLibrary, tag, index), tag);
     });
     _fillLazilyLoadedList(_currentLibrary.fields, (int tag, int index) {
       readField(
           loader.getLibraryMemberReference(_currentLibrary, tag, index), tag);
     });
     _fillLazilyLoadedList(_currentLibrary.procedures, (int tag, int index) {
       readProcedure(
           loader.getLibraryMemberReference(_currentLibrary, tag, index), tag);
     });
     debugPath.removeLast();
   }
 
+  void _readDeferredImports(Library library) {
+    int count = readUInt();
+    library.deferredImports.length = count;
+    for (int i = 0; i < count; ++i) {
+      var importNode = _readDeferredImport();
+      library.deferredImports.add(importNode..parent = library);
+    }
+  }
+
+  DeferredImport _readDeferredImport() {
+    return new DeferredImport(readLibraryReference(), readStringReference());
+  }
+
   void readClass(Class node, int tag) {
     assert(node != null);
     switch (tag) {
       case Tag.NormalClass:
         readNormalClass(node);
         break;
       case Tag.MixinClass:
         readMixinClass(node);
         break;
       default:
@@ skipping 204 matching lines @@
   Expression readExpressionOption() {
     return readAndCheckOptionTag() ? readExpression() : null;
   }
 
   Expression readExpression() {
     int tagByte = readByte();
     int tag = tagByte & Tag.SpecializedTagHighBit == 0
         ? tagByte
         : (tagByte & Tag.SpecializedTagMask);
     switch (tag) {
+      case Tag.LoadLibrary:
+        return new LoadLibrary(readDeferredImportReference());
+      case Tag.CheckLibraryIsLoaded:
+        return new CheckLibraryIsLoaded(readDeferredImportReference());
       case Tag.InvalidExpression:
         return new InvalidExpression();
       case Tag.VariableGet:
         int offset = readOffset();
         return new VariableGet(readVariableReference(), readDartTypeOption())
           ..fileOffset = offset;
       case Tag.SpecializedVariableGet:
         int index = tagByte & Tag.SpecializedPayloadMask;
         int offset = readOffset();
         return new VariableGet(variableStack[index])..fileOffset = offset;
@@ skipping 425 matching lines @@
         isFinal: flags & 0x1 != 0,
         isConst: flags & 0x2 != 0)..fileOffset = offset;
   }
 
   int readOffset() {
     // Offset is saved as unsigned,
     // but actually ranges from -1 and up (thus the -1)
     return readUInt() - 1;
   }
 }