Add access the Message in CompilerDiagnostics.report.

tests/compiler/dart2js/memory_compiler.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 dart2js.test.memory_compiler;
 
 import 'memory_source_file_helper.dart';
 
 
-import 'package:compiler/src/null_compiler_output.dart'
-       show NullCompilerOutput;
+import 'package:compiler/src/null_compiler_output.dart' show
+    NullCompilerOutput;
+
+import 'package:compiler/src/dart2jslib.dart' show
+    Message;
 
 import 'package:compiler/compiler.dart' show
     DiagnosticHandler;
 
 import 'package:compiler/compiler_new.dart' show
+    CompilationResult,
     CompilerDiagnostics,
     CompilerOutput,
     Diagnostic,
     PackagesDiscoveryProvider;
 
 import 'dart:async';
 
 import 'package:compiler/src/mirrors/source_mirrors.dart';
 import 'package:compiler/src/mirrors/analyze.dart';
 
 import 'package:compiler/src/library_loader.dart'
     show LoadedLibraries;
 
-import 'package:compiler/src/old_to_new_api.dart';
-
 export 'output_collector.dart';
+export 'package:compiler/compiler_new.dart' show
+    CompilationResult;
 
 class DiagnosticMessage {
+  final Message message;
   final Uri uri;
   final int begin;
   final int end;
-  final String message;
+  final String text;
   final Diagnostic kind;
 
-  DiagnosticMessage(this.uri, this.begin, this.end, this.message, this.kind);
+  DiagnosticMessage(
+      this.message, this.uri, this.begin, this.end, this.text, this.kind);
 
-  String toString() => '$uri:$begin:$end:$message:$kind';
+  String toString() => '$uri:$begin:$end:$text:$kind';
 }
 
 class DiagnosticCollector implements CompilerDiagnostics {
   List<DiagnosticMessage> messages = <DiagnosticMessage>[];
 
   void call(Uri uri, int begin, int end, String message, Diagnostic kind) {
-    report(uri, begin, end, message, kind);
+    report(null, uri, begin, end, message, kind);
   }
 
   @override
-  void report(Uri uri, int begin, int end, String message, Diagnostic kind) {
-    messages.add(new DiagnosticMessage(uri, begin, end, message, kind));
+  void report(Message message,
+              Uri uri, int begin, int end, String text, Diagnostic kind) {
+    messages.add(new DiagnosticMessage(message, uri, begin, end, text, kind));
   }
 
   Iterable<DiagnosticMessage> filterMessagesByKind(Diagnostic kind) {
     return messages.where(
       (DiagnosticMessage message) => message.kind == kind);
   }
 
   Iterable<DiagnosticMessage> get errors {
     return filterMessagesByKind(Diagnostic.ERROR);
   }
@@ skipping 15 matching lines @@
     return messages.any((m) => m.kind != Diagnostic.VERBOSE_INFO);
   }
 }
 
 class MultiDiagnostics implements CompilerDiagnostics {
   final List<CompilerDiagnostics> diagnosticsList;
 
   const MultiDiagnostics([this.diagnosticsList = const []]);
 
   @override
-  void report(Uri uri, int begin, int end, String message, Diagnostic kind) {
+  void report(Message message, Uri uri, int begin, int end,
+              String text, Diagnostic kind) {
     for (CompilerDiagnostics diagnostics in diagnosticsList) {
-      diagnostics.report(uri, begin, end, message, kind);
+      diagnostics.report(message, uri, begin, end, text, kind);
     }
   }
 }
 
 CompilerDiagnostics createCompilerDiagnostics(
     CompilerDiagnostics diagnostics,
     SourceFileProvider provider,
     bool showDiagnostics) {
   CompilerDiagnostics handler = diagnostics;
   if (showDiagnostics) {
     if (diagnostics == null) {
       handler = new FormattingDiagnosticHandler(provider);
     } else {
       var formattingHandler = new FormattingDiagnosticHandler(provider);
       handler = new MultiDiagnostics([diagnostics, formattingHandler]);
     }
   } else if (diagnostics == null) {
     handler = new MultiDiagnostics();
   }
   return handler;
 }
 
 Expando<MemorySourceFileProvider> expando =
     new Expando<MemorySourceFileProvider>();
 
+Future<CompilationResult> runCompiler(
+    {Map<String, String> memorySourceFiles: const <String, String>{},
+     Uri entryPoint,
+     List<Uri> entryPoints,
+     CompilerDiagnostics diagnosticHandler,
+     CompilerOutput outputProvider,
+     List<String> options: const <String>[],
+     Compiler cachedCompiler,
+     bool showDiagnostics: true,
+     Uri packageRoot,
+     Uri packageConfig,
+     PackagesDiscoveryProvider packagesDiscoveryProvider,
+     void beforeRun(Compiler compiler)}) async {
+  if (entryPoint == null) {
+    entryPoint = Uri.parse('memory:main.dart');
+  }
+  Compiler compiler = compilerFor(
+      memorySourceFiles,
+      diagnosticHandler: diagnosticHandler,
+      outputProvider: outputProvider,
+      options: options,
+      cachedCompiler: cachedCompiler,
+      showDiagnostics: showDiagnostics,
+      packageRoot: packageRoot,
+      packageConfig: packageConfig,
+      packagesDiscoveryProvider: packagesDiscoveryProvider);
+  compiler.librariesToAnalyzeWhenRun = entryPoints;
+  if (beforeRun != null) {
+    beforeRun(compiler);
+  }
+  bool isSuccess = await compiler.run(entryPoint);
+  return new CompilationResult(compiler, isSuccess: isSuccess);
+}
+
 Compiler compilerFor(
     Map<String, String> memorySourceFiles,
     {CompilerDiagnostics diagnosticHandler,
      CompilerOutput outputProvider,
-     List<String> options: const [],
+     List<String> options: const <String>[],
      Compiler cachedCompiler,
      bool showDiagnostics: true,
      Uri packageRoot,
      Uri packageConfig,
      PackagesDiscoveryProvider packagesDiscoveryProvider}) {
   Uri libraryRoot = Uri.base.resolve('sdk/');
   if (packageRoot == null &&
       packageConfig == null &&
       packagesDiscoveryProvider == null) {
     packageRoot = Uri.base.resolveUri(new Uri.file('${Platform.packageRoot}/'));
@@ skipping 153 matching lines @@
       createDiagnosticHandler(diagnosticHandler, provider, showDiagnostics);
 
   List<Uri> libraries = <Uri>[];
   memorySourceFiles.forEach((String path, _) {
     libraries.add(new Uri(scheme: 'memory', path: path));
   });
 
   return analyze(libraries, libraryRoot, packageRoot,
                  provider, handler, options);
 }