Support loading binary data in dart2js

pkg/compiler/lib/src/source_file_provider.dart

 // Copyright (c) 2013, 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 source_file_provider;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:math' as math;
 import 'dart:typed_data';
 
 import '../compiler.dart' as api show Diagnostic;
 import '../compiler_new.dart' as api;
 import '../compiler_new.dart';
 import 'colors.dart' as colors;
 import 'dart2js.dart' show AbortLeg;
 import 'filenames.dart';
 import 'io/source_file.dart';
 import 'util/uri_extras.dart';
 
 abstract class SourceFileProvider implements CompilerInput {
   bool isWindows = (Platform.operatingSystem == 'windows');
   Uri cwd = currentDirectory;
-  Map<Uri, SourceFile> sourceFiles = <Uri, SourceFile>{};
+  Map<Uri, api.Input> sourceFiles = <Uri, api.Input>{};
   int dartCharactersRead = 0;
 
-  Future<List<int>> readUtf8BytesFromUri(Uri resourceUri) {
+  Future<api.Input> readBytesFromUri(Uri resourceUri, api.InputKind inputKind) {
     if (resourceUri.scheme == 'file') {
-      return _readFromFile(resourceUri);
+      return _readFromFile(resourceUri, inputKind);
     } else if (resourceUri.scheme == 'http' || resourceUri.scheme == 'https') {
-      return _readFromHttp(resourceUri);
+      return _readFromHttp(resourceUri, inputKind);
     } else {
       throw new ArgumentError("Unknown scheme in uri '$resourceUri'");
     }
   }
 
-  Future<List<int>> _readFromFile(Uri resourceUri) {
+  Future<api.Input> _readFromFile(Uri resourceUri, api.InputKind inputKind) {
     assert(resourceUri.scheme == 'file');
     List<int> source;
     try {
-      source = readAll(resourceUri.toFilePath());
+      source = readAll(resourceUri.toFilePath(),
+          zeroTerminated: inputKind == api.InputKind.utf8);
     } on FileSystemException catch (ex) {
       String message = ex.osError?.message;
       String detail = message != null ? ' ($message)' : '';
       return new Future.error(
           "Error reading '${relativizeUri(resourceUri)}' $detail");
     }
     dartCharactersRead += source.length;
-    sourceFiles[resourceUri] = new CachingUtf8BytesSourceFile(
-        resourceUri, relativizeUri(resourceUri), source);
-    return new Future.value(source);
+    api.Input input;
+    switch (inputKind) {
+      case api.InputKind.utf8:
+        input = new CachingUtf8BytesSourceFile(
+            resourceUri, relativizeUri(resourceUri), source);
+        break;
+      case api.InputKind.binary:
+        input = new Binary(resourceUri, source);
+        break;
+    }
+    sourceFiles[resourceUri] = input;
+    return new Future.value(input);
   }
 
-  Future<List<int>> _readFromHttp(Uri resourceUri) {
+  Future<api.Input> _readFromHttp(Uri resourceUri, api.InputKind inputKind) {
     assert(resourceUri.scheme == 'http');
     HttpClient client = new HttpClient();
     return client
         .getUrl(resourceUri)
         .then((HttpClientRequest request) => request.close())
         .then((HttpClientResponse response) {
       if (response.statusCode != HttpStatus.OK) {
         String msg = 'Failure getting $resourceUri: '
             '${response.statusCode} ${response.reasonPhrase}';
         throw msg;
       }
       return response.toList();
     }).then((List<List<int>> splitContent) {
       int totalLength = splitContent.fold(0, (int old, List list) {
         return old + list.length;
       });
       Uint8List result = new Uint8List(totalLength);
       int offset = 0;
       for (List<int> contentPart in splitContent) {
         result.setRange(offset, offset + contentPart.length, contentPart);
         offset += contentPart.length;
       }
       dartCharactersRead += totalLength;
-      sourceFiles[resourceUri] = new CachingUtf8BytesSourceFile(
-          resourceUri, resourceUri.toString(), result);
-      return result;
+      api.Input input;
+      switch (inputKind) {
+        case api.InputKind.utf8:
+          input = new CachingUtf8BytesSourceFile(
+              resourceUri, resourceUri.toString(), result);
+          break;
+        case api.InputKind.binary:
+          input = new Binary(resourceUri, result);
+          break;
+      }
+      sourceFiles[resourceUri] = input;
+      return input;
     });
   }
 
   // TODO(johnniwinther): Remove this when no longer needed for the old compiler
   // API.
   Future /* <List<int> | String> */ call(Uri resourceUri) {
     throw "unimplemented";
   }
 
   relativizeUri(Uri uri) => relativize(cwd, uri, isWindows);
 
   SourceFile getSourceFile(Uri resourceUri) {
     return sourceFiles[resourceUri];
   }
 }
 
-List<int> readAll(String filename) {
-  var file = (new File(filename)).openSync();
-  var length = file.lengthSync();
-  // +1 to have a 0 terminated list, see [Scanner].
-  var buffer = new Uint8List(length + 1);
+List<int> readAll(String filename, {bool zeroTerminated: true}) {
+  RandomAccessFile file = (new File(filename)).openSync();
+  int length = file.lengthSync();
+  int bufferLength = length;
+  if (zeroTerminated) {
+    // +1 to have a 0 terminated list, see [Scanner].
+    bufferLength++;
+  }
+  var buffer = new Uint8List(bufferLength);
   file.readIntoSync(buffer, 0, length);
   file.closeSync();
   return buffer;
 }
 
 class CompilerSourceFileProvider extends SourceFileProvider {
   // TODO(johnniwinther): Remove this when no longer needed for the old compiler
   // API.
   Future<List<int>> call(Uri resourceUri) => readFromUri(resourceUri);
 
   @override
-  Future readFromUri(Uri uri) => readUtf8BytesFromUri(uri);
+  Future readFromUri(Uri uri, {InputKind inputKind: InputKind.utf8}) =>
+      readBytesFromUri(uri, inputKind);
 }
 
 class FormattingDiagnosticHandler implements CompilerDiagnostics {
   final SourceFileProvider provider;
   bool showWarnings = true;
   bool showHints = true;
   bool verbose = false;
   bool isAborting = false;
   bool enableColors = false;
   bool throwOnError = false;
@@ skipping 74 matching lines @@
       color = colors.green;
     } else {
       throw 'Unknown kind: $kind (${kind.ordinal})';
     }
     if (!enableColors) {
       color = (x) => x;
     }
     if (uri == null) {
       print('${color(message)}');
     } else {
-      SourceFile file = provider.sourceFiles[uri];
-      // TODO(johnniwinther): Remove the '.dill' hack; add support for binary
-      // files to avoid crashes on trying to decode .dill binaries as utf8.
-      if (file != null && !file.filename.endsWith('.dill')) {
+      api.Input file = provider.sourceFiles[uri];
+      if (file is SourceFile) {
         print(file.getLocationMessage(color(message), begin, end,
             colorize: color));
       } else {
         String position = end - begin > 0 ? '@$begin+${end - begin}' : '';
         print('${provider.relativizeUri(uri)}$position:\n'
             '${color(message)}');
       }
     }
     if (fatal && ++fatalCount >= throwOnErrorCount && throwOnError) {
       isAborting = true;
@@ skipping 178 matching lines @@
 /// `/bazel-root/a/b.dart` which will likely fail.
 class BazelInputProvider extends SourceFileProvider {
   final List<Uri> dirs;
 
   BazelInputProvider(List<String> searchPaths)
       : dirs = searchPaths.map(_resolve).toList();
 
   static _resolve(String path) => currentDirectory.resolve(path);
 
   @override
-  Future readFromUri(Uri uri) async {
+  Future<api.Input> readFromUri(Uri uri,
+      {InputKind inputKind: InputKind.utf8}) async {
     var resolvedUri = uri;
     var path = uri.path;
     if (path.startsWith('/bazel-root')) {
       path = path.substring('/bazel-root/'.length);
       for (var dir in dirs) {
         var file = dir.resolve(path);
         if (await new File.fromUri(file).exists()) {
           resolvedUri = file;
           break;
         }
       }
     }
-    List<int> result = await readUtf8BytesFromUri(resolvedUri);
+    api.Input result = await readBytesFromUri(resolvedUri, inputKind);
     sourceFiles[uri] = sourceFiles[resolvedUri];
     return result;
   }
 }