Make reporter customizable

pkg/compiler/lib/src/compiler.dart

 // Copyright (c) 2012, 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.compiler_base;
 
 import 'dart:async' show
     EventSink,
     Future;
 
@@ skipping 129 matching lines @@
 import 'universe/use.dart' show
     StaticUse;
 import 'universe/world_impact.dart' show
     WorldImpact;
 import 'util/util.dart' show
     Link,
     Setlet;
 import 'world.dart' show
     World;
 
+typedef Backend MakeBackendFuncion(Compiler compiler);
+
+typedef CompilerDiagnosticReporter MakeReporterFunction(
+    Compiler compiler, DiagnosticOptions diagnosticOptions);
+
 abstract class Compiler {
   /// Helper instance for measurements in [CompilerTask].
   ///
   /// Note: MUST be first field to ensure [Measurer.wallclock] is started
   /// before other computations.
   final Measurer measurer = new Measurer();
 
   int nextFreeClassId = 0;
   World world;
   Types types;
   _CompilerCoreTypes _coreTypes;
-  _CompilerDiagnosticReporter _reporter;
+  CompilerDiagnosticReporter _reporter;
   _CompilerResolution _resolution;
   _CompilerParsing _parsing;
 
   final CacheStrategy cacheStrategy;
 
   /**
    * Map from token to the first preceding comment token.
    */
   final TokenMap commentMap = new TokenMap();
 
@@ skipping 279 matching lines @@
             this.useContentSecurityPolicy: false,
             bool hasIncrementalSupport: false,
             this.enableExperimentalMirrors: false,
             this.enableAssertMessage: false,
             this.allowNativeExtensions: false,
             this.generateCodeWithCompileTimeErrors: false,
             this.testMode: false,
             DiagnosticOptions diagnosticOptions,
             api.CompilerOutput outputProvider,
             List<String> strips: const [],
-            Backend makeBackend(Compiler compiler)})
+            MakeBackendFuncion makeBackend,
+            MakeReporterFunction makeReporter})
       : this.disableTypeInferenceFlag =
             disableTypeInferenceFlag || !emitJavaScript,
         this.analyzeOnly =
             analyzeOnly || analyzeSignaturesOnly || analyzeAllFlag,
         this.analyzeSignaturesOnly = analyzeSignaturesOnly,
         this.analyzeAllFlag = analyzeAllFlag,
         this.hasIncrementalSupport = hasIncrementalSupport,
         cacheStrategy = new CacheStrategy(hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput() : outputProvider {
     if (hasIncrementalSupport) {
       // TODO(ahe): This is too much. Any method from platform and package
       // libraries can be inlined.
       disableInlining = true;
     }
     world = new World(this);
-    // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
-    // make its field final.
-    _reporter = new _CompilerDiagnosticReporter(this, diagnosticOptions);
+    if (makeReporter != null) {
+      _reporter = makeReporter(this, diagnosticOptions);
+    } else {
+      // TODO(johnniwinther): Initialize core types in [initializeCoreClasses]
+      // and make its field final.
+      _reporter = new CompilerDiagnosticReporter(this, diagnosticOptions);
+    }
     _parsing = new _CompilerParsing(this);
     _resolution = new _CompilerResolution(this);
     _coreTypes = new _CompilerCoreTypes(_resolution);
     types = new Types(_resolution);
     tracer = new Tracer(this, this.outputProvider);
 
     if (verbose) {
       progress = new Stopwatch()..start();
     }
 
@@ skipping 1117 matching lines @@
   InterfaceType streamType([DartType elementType]) {
     streamClass.ensureResolved(resolution);
     InterfaceType type = streamClass.rawType;
     if (elementType == null) {
       return type;
     }
     return type.createInstantiation([elementType]);
   }
 }
 
-class _CompilerDiagnosticReporter extends DiagnosticReporter {
+class CompilerDiagnosticReporter extends DiagnosticReporter {
   final Compiler compiler;
   final DiagnosticOptions options;
 
   Element _currentElement;
   bool hasCrashed = false;
 
   /// `true` if the last diagnostic was filtered, in which case the
   /// accompanying info message should be filtered as well.
   bool lastDiagnosticWasFiltered = false;
 
   /// Map containing information about the warnings and hints that have been
   /// suppressed for each library.
   Map<Uri, SuppressionInfo> suppressedWarnings = <Uri, SuppressionInfo>{};
 
-  _CompilerDiagnosticReporter(this.compiler, this.options);
+  CompilerDiagnosticReporter(this.compiler, this.options);
 
   Element get currentElement => _currentElement;
 
   DiagnosticMessage createMessage(
       Spannable spannable,
       MessageKind messageKind,
       [Map arguments = const {}]) {
     SourceSpan span = spanFromSpannable(spannable);
     MessageTemplate template = MessageTemplate.TEMPLATES[messageKind];
     Message message = template.message(arguments, options.terseDiagnostics);
@@ skipping 453 matching lines @@
     if (_otherDependencies == null) {
       _otherDependencies = new Setlet<Element>();
     }
     _otherDependencies.add(element.implementation);
   }
 
   Iterable<Element> get otherDependencies {
     return _otherDependencies != null ? _otherDependencies : const <Element>[];
   }
 }