[kernel] Delete most of the AST

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 'dart:convert';
 import 'dart:typed_data';
 
 import '../ast.dart';
 import '../transformations/flags.dart';
@@ skipping 50 matching lines @@
       return ((byte & 0x3F) << 8) | readByte();
     } else {
       // 11xxxxxx
       return ((byte & 0x3F) << 24) |
           (readByte() << 16) |
           (readByte() << 8) |
           readByte();
     }
   }
 
-  int readMagicWord() {
+  int readUint32() {
     return (readByte() << 24) |
         (readByte() << 16) |
         (readByte() << 8) |
         readByte();
   }
 
   List<int> readUtf8Bytes() {
     List<int> bytes = new Uint8List(readUInt());
     bytes.setRange(0, bytes.length, _bytes, _byteIndex);
     _byteIndex += bytes.length;
@@ skipping 148 matching lines @@
   ///
   /// When linking with a non-empty program, canonical names must have been
   /// computed ahead of time.
   ///
   /// This should *only* be used when there is a reason to not allow
   /// concatenated files.
   void readSingleFileProgram(Program program) {
     _readOneProgram(program);
     if (_byteIndex < _bytes.length) {
       if (_byteIndex + 3 < _bytes.length) {
-        int magic = readMagicWord();
+        int magic = readUint32();
         if (magic == Tag.ProgramFile) {
           throw 'Concatenated program file given when a single program '
               'was expected.';
         }
       }
       throw 'Unrecognized bytes following program data';
     }
   }
 
   void _readOneProgram(Program program) {
-    int magic = readMagicWord();
+    int magic = readUint32();
     if (magic != Tag.ProgramFile) {
       throw fail('This is not a binary dart file. '
           'Magic number was: ${magic.toRadixString(16)}');
     }
     readStringTable(_stringTable);
     Map<String, Source> uriToSource = readUriToSource();
     program.uriToSource.addAll(uriToSource);
     readLinkTable(program.root);
     int numberOfLibraries = readUInt();
     List<Library> libraries = new List<Library>(numberOfLibraries);
     for (int i = 0; i < numberOfLibraries; ++i) {
       libraries[i] = readLibrary(program);
     }
     var mainMethod = readMemberReference(allowNull: true);
     program.mainMethodName ??= mainMethod;
+    readUint32(); // binary offset for source table.
+    readUint32(); // binary offset for link table.
+    readUint32(); // main
+    for (int i = 0; i < numberOfLibraries; i++) {
+      readUint32(); // binary offset for library #i.
+    }
+    int numberOfLibrariesCheck = readUint32();
+    if (numberOfLibraries != numberOfLibrariesCheck) {
+      throw "Expected number of libraries to match!";

[Kevin Millikin (Google), 2017/06/29 12:27:36]

Even if you're just throwing a string and not some structured exception, make it
informative.  Something like:

'Malformed binary: the table of contents indicates there are
$numberOfLibrariesCheck libraries but the binary contains $numberOfLibraries.'

Perhaps we can also throw if there is anything else (add a method to the reader
that reports if it is at the end of the stream).

[jensj, 2017/06/30 05:51:17]

I'm not sure about throwing if we're not at the end --- readProgram indicates
that we can have several programs in the same dill file, though I'm not sure
when that's applicable?

+    }
   }
 
   Map<String, Source> readUriToSource() {
     readStringTable(_sourceUriTable);
     int length = _sourceUriTable.length;
     Map<String, Source> uriToSource = <String, Source>{};
     for (int i = 0; i < length; ++i) {
       String uri = _sourceUriTable[i];
       List<int> sourceCode = readUtf8Bytes();
       int lineCount = readUInt();
@@ skipping 924 matching lines @@
       ..fileOffset = offset
       ..fileEqualsOffset = fileEqualsOffset;
   }
 
   int readOffset() {
     // Offset is saved as unsigned,
     // but actually ranges from -1 and up (thus the -1)
     return readUInt() - 1;
   }
 }