Add interfaces for a new compiler API.

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:convert';
 import 'dart:io';
 import 'dart:math' as math;
 
 import '../compiler.dart' as api show Diagnostic, DiagnosticHandler;
+import '../compiler_new.dart' as api show CompilerInput, CompilerDiagnostics;
 import 'dart2js.dart' show AbortLeg;
 import 'colors.dart' as colors;
 import 'io/source_file.dart';
 import 'filenames.dart';
 import 'util/uri_extras.dart';
 import 'dart:typed_data';
+import '../compiler_new.dart';
 
 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);
   file.readIntoSync(buffer, 0, length);
   file.closeSync();
   return buffer;
 }
 
-abstract class SourceFileProvider {
+abstract class SourceFileProvider implements CompilerInput {
   bool isWindows = (Platform.operatingSystem == 'windows');
   Uri cwd = currentDirectory;
   Map<Uri, SourceFile> sourceFiles = <Uri, SourceFile>{};
   int dartCharactersRead = 0;
 
   Future<String> readStringFromUri(Uri resourceUri) {
     return readUtf8BytesFromUri(resourceUri).then(UTF8.decode);
   }
 
   Future<List<int>> readUtf8BytesFromUri(Uri resourceUri) {
@@ skipping 52 matching lines @@
              offset += contentPart.length;
            }
            dartCharactersRead += totalLength;
            sourceFiles[resourceUri] =
                new CachingUtf8BytesSourceFile(
                    resourceUri, resourceUri.toString(), result);
            return result;
          });
   }
 
+  // TODO(johnniwinther): Remove this when no longer needed for the old compiler
+  // API.
   Future/*<List<int> | String>*/ call(Uri resourceUri);
 
   relativizeUri(Uri uri) => relativize(cwd, uri, isWindows);
 
   SourceFile getSourceFile(Uri resourceUri) {
     return sourceFiles[resourceUri];
   }
 }
 
 class CompilerSourceFileProvider extends SourceFileProvider {
-  Future<List<int>> call(Uri resourceUri) => readUtf8BytesFromUri(resourceUri);
+  // 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);
 }
 
-class FormattingDiagnosticHandler {
+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;
   int throwOnErrorCount = 0;
   api.Diagnostic lastKind = null;
   int fatalCount = 0;
@@ skipping 26 matching lines @@
         return 'Hint: $message';
       case api.Diagnostic.CRASH:
         return 'Internal Error: $message';
       case api.Diagnostic.INFO:
       case api.Diagnostic.VERBOSE_INFO:
         return 'Info: $message';
     }
     throw 'Unexpected diagnostic kind: $kind (${kind.ordinal})';
   }
 
-  void diagnosticHandler(Uri uri, int begin, int end, String message,
-                         api.Diagnostic kind) {
+  @override
+  void report(Uri uri, int begin, int end, String message,
+                        api.Diagnostic kind) {
     // TODO(ahe): Remove this when source map is handled differently.
     if (identical(kind.name, 'source map')) return;
 
     if (isAborting) return;
     isAborting = (kind == api.Diagnostic.CRASH);
 
     bool fatal = (kind.ordinal & FATAL) != 0;
     bool isInfo = (kind.ordinal & INFO) != 0;
     if (isInfo && uri == null && kind != api.Diagnostic.INFO) {
       info(message, kind);
@@ skipping 41 matching lines @@
         print('${provider.relativizeUri(uri)}$position:\n'
               '${color(message)}');
       }
     }
     if (fatal && ++fatalCount >= throwOnErrorCount && throwOnError) {
       isAborting = true;
       throw new AbortLeg(message);
     }
   }
 
+  // TODO(johnniwinther): Remove this when no longer needed for the old compiler
+  // API.
   void call(Uri uri, int begin, int end, String message, api.Diagnostic kind) {
-    return diagnosticHandler(uri, begin, end, message, kind);
+    return report(uri, begin, end, message, kind);
   }
 }
 
 typedef void MessageCallback(String message);
 
 class RandomAccessFileOutputProvider {
   final Uri out;
   final Uri sourceMapOut;
   final MessageCallback onInfo;
   final MessageCallback onFailure;
@@ skipping 87 matching lines @@
   var onAdd, onClose;
 
   EventSinkWrapper(this.onAdd, this.onClose);
 
   void add(String data) => onAdd(data);
 
   void addError(error, [StackTrace stackTrace]) => throw error;
 
   void close() => onClose();
 }