FileState needs only bytes of the file.

pkg/front_end/lib/src/incremental/file_state.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
-import 'dart:convert';
 import 'dart:typed_data';
 
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/fasta/parser/top_level_parser.dart';
 import 'package:front_end/src/fasta/scanner.dart';
 import 'package:front_end/src/fasta/source/directive_listener.dart';
 import 'package:front_end/src/fasta/translate_uri.dart';
 
 /// Information about a file being compiled, explicitly or implicitly.
 ///
 /// It provides a consistent view on its properties.
 ///
 /// The properties are not guaranteed to represent the most recent state
 /// of the file system. To update the file to the most recent state, [refresh]
 /// should be called.
 class FileState {
   final FileSystemState _fsState;
 
   /// The resolved URI of the file in the file system.
   final Uri fileUri;
 
   bool _exists;
-  List<int> _contentBytes;
-  String _content;
+  List<int> _content;
 
   List<FileState> _importedFiles;
   List<FileState> _exportedFiles;
   List<FileState> _partFiles;
 
   Set<FileState> _directReferencedFiles = new Set<FileState>();
 
   FileState._(this._fsState, this.fileUri);
 
   /// The content of the file.
-  String get content => _content;
-
-  /// The content bytes of the file.
-  List<int> get contentBytes => _contentBytes;
+  List<int> get content => _content;
 
   /// Whether the file exists.
   bool get exists => _exists;
 
   @override
   int get hashCode => fileUri.hashCode;
 
   /// Return the set of transitive files - the file itself and all of the
   /// directly or indirectly referenced files.
   Set<FileState> get transitiveFiles {
@@ skipping 14 matching lines @@
   bool operator ==(Object other) {
     return other is FileState && other.fileUri == fileUri;
   }
 
   /// Read the file content and ensure that all of the file properties are
   /// consistent with the read content, including all its dependencies.
   Future<Null> refresh() async {
     // Read the content.
     try {
       FileSystemEntity entry = _fsState.fileSystem.entityForUri(fileUri);
-      _contentBytes = await entry.readAsBytes();
-      _content = UTF8.decode(_contentBytes);
+      _content = await entry.readAsBytes();
       _exists = true;
     } catch (_) {
-      _contentBytes = new Uint8List(0);
-      _content = '';
+      _content = new Uint8List(0);
       _exists = false;
     }
 
     // Parse directives.
-    ScannerResult scannerResults = scanString(_content);
+    ScannerResult scannerResults = _scan();
     var listener = new DirectiveListener();
     new TopLevelParser(listener).parseUnit(scannerResults.tokens);
 
     // Build the graph.
     _importedFiles = <FileState>[];
     _exportedFiles = <FileState>[];
     _partFiles = <FileState>[];
     await _addFileForRelativeUri(_importedFiles, 'dart:core');
     for (String uri in listener.imports) {
       await _addFileForRelativeUri(_importedFiles, uri);
@@ skipping 29 matching lines @@
       return;
     }
 
     // Resolve the absolute URI into the absolute file URI.
     Uri resolvedUri = _fsState.uriTranslator.translate(absoluteUri);
     if (resolvedUri == null) return;
 
     FileState file = await _fsState.getFile(resolvedUri);
     files.add(file);
   }
+
+  /// Scan the content of the file.
+  ScannerResult _scan() {
+    var zeroTerminatedBytes = new Uint8List(_content.length + 1);
+    zeroTerminatedBytes.setRange(0, _content.length, _content);
+    return scan(zeroTerminatedBytes);
+  }
 }
 
 /// Information about known file system state.
 class FileSystemState {
   final FileSystem fileSystem;
   final TranslateUri uriTranslator;
 
   _FileSystemView _fileSystemView;
 
   /// Mapping from file URIs to corresponding [FileState]s.
@@ skipping 41 matching lines @@
 /// [FileSystemState] based implementation of [FileSystemEntity].
 class _FileSystemViewEntry implements FileSystemEntity {
   @override
   final Uri uri;
 
   final FileState file;
 
   _FileSystemViewEntry(this.uri, this.file);
 
   @override
-  Future<bool> exists() async => file?.exists ?? false;
+  Future<bool> exists() async => _shouldNotBeQueried();
 
   @override
-  Future<DateTime> lastModified() async {
-    throw new StateError(
-        'FileSystemViewEntry modification stamp should not be queried');
+  Future<DateTime> lastModified() async => _shouldNotBeQueried();
+
+  @override
+  Future<List<int>> readAsBytes() async {
+    if (file == null) {
+      throw new FileSystemException(uri, 'File $uri does not exist.');
+    }
+    return file.content;
   }
 
   @override
-  Future<List<int>> readAsBytes() async {
-    _throwIfDoesNotExist();
-    return file.contentBytes;
-  }
+  Future<String> readAsString() async => _shouldNotBeQueried();
 
-  @override
-  Future<String> readAsString() async {
-    _throwIfDoesNotExist();
-    return file.content;
-  }
-
-  void _throwIfDoesNotExist() {
-    if (file == null) {
-      throw new FileSystemException(uri, 'File $uri does not exist.');
-    }
+  /// _FileSystemViewEntry is used by the incremental kernel generator to
+  /// provide Fasta with a consistent, race condition free view of the files
+  /// constituting the project.  It should only need to be used for reading
+  /// file contents.
+  dynamic _shouldNotBeQueried() {
+    throw new StateError('The method should not be invoked.');
   }
 }