Add closure_test for kernel based members

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';
@@ skipping 16 matching lines @@
   Future<api.Input> readBytesFromUri(Uri resourceUri, api.InputKind inputKind) {
     if (resourceUri.scheme == 'file') {
       return _readFromFile(resourceUri, inputKind);
     } else if (resourceUri.scheme == 'http' || resourceUri.scheme == 'https') {
       return _readFromHttp(resourceUri, inputKind);
     } else {
       throw new ArgumentError("Unknown scheme in uri '$resourceUri'");
     }
   }
 
-  Future<api.Input> _readFromFile(Uri resourceUri, api.InputKind inputKind) {
+  api.Input _readFromFileSync(Uri resourceUri, api.InputKind inputKind) {
     assert(resourceUri.scheme == 'file');
     List<int> source;
     try {
       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");
+      throw "Error reading '${relativizeUri(resourceUri)}' $detail";
     }
     dartCharactersRead += source.length;
     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 input;
+  }
+
+  /// Read [resourceUri] directly as a UTF-8 file. If reading fails, `null` is
+  /// returned.
+  api.Input autoReadFromFile(Uri resourceUri) {
+    try {
+      return _readFromFileSync(resourceUri, InputKind.utf8);
+    } catch (e) {
+      // Silence the error. The [resourceUri] was not requested by the user and
+      // was only needed to give better error messages.
+    }
+    return null;
+  }
+
+  Future<api.Input> _readFromFile(Uri resourceUri, api.InputKind inputKind) {
+    api.Input input;
+    try {
+      input = _readFromFileSync(resourceUri, inputKind);
+    } catch (e) {
+      return new Future.error(e);
+    }
     return new Future.value(input);
   }
 
   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) {
@@ skipping 69 matching lines @@
 }
 
 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;
+  bool autoReadFileUri = false;
   int throwOnErrorCount = 0;
   api.Diagnostic lastKind = null;
   int fatalCount = 0;
 
   final int FATAL = api.Diagnostic.CRASH.ordinal | api.Diagnostic.ERROR.ordinal;
   final int INFO =
       api.Diagnostic.INFO.ordinal | api.Diagnostic.VERBOSE_INFO.ordinal;
 
   FormattingDiagnosticHandler([SourceFileProvider provider])
       : this.provider =
@@ skipping 65 matching lines @@
     } else {
       throw 'Unknown kind: $kind (${kind.ordinal})';
     }
     if (!enableColors) {
       color = (x) => x;
     }
     if (uri == null) {
       print('${color(message)}');
     } else {
       api.Input file = provider.sourceFiles[uri];
+      if (file == null &&
+          autoReadFileUri &&
+          uri.scheme == 'file' &&
+          uri.path.endsWith('.dart')) {
+        // When reading from .dill files, the original source files haven't been
+        // loaded. Load the file if possible to provide a better error message.
+        file = provider.autoReadFromFile(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) {
@@ skipping 198 matching lines @@
           resolvedUri = file;
           break;
         }
       }
     }
     api.Input result = await readBytesFromUri(resolvedUri, inputKind);
     sourceFiles[uri] = sourceFiles[resolvedUri];
     return result;
   }
 }