Use FileSystem to read files in SourceLoader and TranslateUri.

pkg/front_end/lib/src/fasta/source/source_loader.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 fasta.source_loader;
 
 import 'dart:async' show Future;
 
+import 'dart:io';
 import 'dart:typed_data' show Uint8List;
 
+import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/instrumentation.dart' show Instrumentation;
 
 import 'package:front_end/src/fasta/builder/ast_factory.dart' show AstFactory;
 
 import 'package:front_end/src/fasta/kernel/kernel_ast_factory.dart'
     show KernelAstFactory;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
     show KernelTypeInferenceEngine;
 
@@ skipping 16 matching lines @@
 import '../errors.dart' show inputError;
 
 import '../export.dart' show Export;
 
 import '../loader.dart' show Loader;
 
 import '../parser/class_member_parser.dart' show ClassMemberParser;
 
 import '../scanner.dart' show ErrorToken, ScannerResult, Token, scan;
 
-import '../io.dart' show readBytesFromFile;
-
 import 'diet_listener.dart' show DietListener;
 
 import 'diet_parser.dart' show DietParser;
 
 import 'outline_builder.dart' show OutlineBuilder;
 
 import 'source_class_builder.dart' show SourceClassBuilder;
 
 import 'source_library_builder.dart' show SourceLibraryBuilder;
 
 class SourceLoader<L> extends Loader<L> {
+  /// The [FileSystem] which should be used to access files.
+  final FileSystem fileSystem;
+
   final Map<Uri, List<int>> sourceBytes = <Uri, List<int>>{};
   final bool excludeSource = CompilerContext.current.options.excludeSource;
 
   // Used when building directly to kernel.
   ClassHierarchy hierarchy;
   CoreTypes coreTypes;
 
   final AstFactory astFactory = new KernelAstFactory();
 
   TypeInferenceEngine typeInferenceEngine;
 
   Instrumentation instrumentation;
 
-  SourceLoader(KernelTarget target) : super(target);
+  SourceLoader(this.fileSystem, KernelTarget target) : super(target);
 
   Future<Token> tokenize(SourceLibraryBuilder library,
       {bool suppressLexicalErrors: false}) async {
     Uri uri = library.fileUri;
     if (uri == null || uri.scheme != "file") {
       return inputError(library.uri, -1, "Not found: ${library.uri}.");
     }
+
+    // Get the library text from the cache, or read from the file system.
     List<int> bytes = sourceBytes[uri];
     if (bytes == null) {
-      bytes = sourceBytes[uri] = await readBytesFromFile(uri);
+      try {
+        List<int> rawBytes = await fileSystem.entityForUri(uri).readAsBytes();
+        Uint8List zeroTerminatedBytes = new Uint8List(rawBytes.length + 1);
+        zeroTerminatedBytes.setRange(0, rawBytes.length, rawBytes);

[ahe, 2017/05/08 10:06:14]

I'd appreciate if we can roll this back until the API supports reading into a a
byte list.

Copying bytes is expensive.

[Siggi Cherem (dart-lang), 2017/05/08 16:38:22]

Another option: instead of adding an API to read into a list, we could extend
the readAsBytes API to match scanner/io.dart#readBytesFromFile  (take an
optional `ensureZeroTermination` boolean)

[scheglov, 2017/05/08 16:53:36]

Well, we could do this.
OTOH API bloating is not nice.

+        bytes = zeroTerminatedBytes;
+        sourceBytes[uri] = bytes;
+      } on FileSystemException catch (e) {
+        // TODO(scheglov) Throw and catch abstract file-system exceptions.
+        String message = e.message;
+        String osMessage = e.osError?.message;
+        if (osMessage != null && osMessage.isNotEmpty) {
+          message = osMessage;
+        }
+        return inputError(uri, -1, message);
+      }
     }
+
     byteCount += bytes.length - 1;
     ScannerResult result = scan(bytes);
     Token token = result.tokens;
     if (!suppressLexicalErrors) {
       List<int> source = getSource(bytes);
       target.addSourceInformation(library.fileUri, result.lineStarts, source);
     }
     while (token is ErrorToken) {
       if (!suppressLexicalErrors) {
         ErrorToken error = token;
@@ skipping 305 matching lines @@
   /// Performs the second phase of top level initializer inference, which is to
   /// visit fields and top level variables in topologically-sorted order and
   /// assign their types.
   void performInitializerInference() {
     typeInferenceEngine.finishTopLevel();
     ticker.logMs("Performed initializer inference");
   }
 
   List<Uri> getDependencies() => sourceBytes.keys.toList();
 }