Make reporter customizable

pkg/compiler/lib/src/apiimpl.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 leg_apiimpl;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:package_config/packages.dart';
@@ skipping 24 matching lines @@
 
 const bool forceIncrementalSupport =
     const bool.fromEnvironment('DART2JS_EXPERIMENTAL_INCREMENTAL_SUPPORT');
 
 /// Locations of the platform descriptor files relative to the library root.
 const String _clientPlatform = "lib/dart_client.platform";
 const String _serverPlatform = "lib/dart_server.platform";
 const String _sharedPlatform = "lib/dart_shared.platform";
 const String _dart2dartPlatform = "lib/dart2dart.platform";
 
+typedef DiagnosticOptions MakeDiagnosticOptionsFunction(
+    {bool suppressWarnings,
+     bool fatalWarnings,
+     bool suppressHints,
+     bool terseDiagnostics,
+     bool showPackageWarnings});
+
+DiagnosticOptions makeDiagnosticOptions(
+    {bool suppressWarnings: false,
+     bool fatalWarnings: false,
+     bool suppressHints: false,
+     bool terseDiagnostics: false,
+     bool showPackageWarnings: false}) {
+  return new DiagnosticOptions(
+      suppressWarnings: suppressWarnings,
+      fatalWarnings: fatalWarnings,
+      suppressHints: suppressHints,
+      terseDiagnostics: terseDiagnostics,
+      showPackageWarnings: showPackageWarnings);
+}
+
 /// Implements the [Compiler] using a [api.CompilerInput] for supplying the
 /// sources.
 class CompilerImpl extends Compiler {
   api.CompilerInput provider;
   api.CompilerDiagnostics handler;
   final Uri platformConfigUri;
   final Uri packageConfig;
   final Uri packageRoot;
   final api.PackagesDiscoveryProvider packagesDiscoveryProvider;
   Packages packages;
   List<String> options;
   Map<String, dynamic> environment;
   bool mockableLibraryUsed = false;
 
   /// A mapping of the dart: library-names to their location.
   ///
   /// Initialized in [setupSdk].
   Map<String, Uri> sdkLibraries;
 
   GenericTask userHandlerTask;
   GenericTask userProviderTask;
   GenericTask userPackagesDiscoveryTask;
 
   Uri get libraryRoot => platformConfigUri.resolve(".");
 
-  CompilerImpl(this.provider,
-           api.CompilerOutput outputProvider,
-           this.handler,
-           Uri libraryRoot,
-           this.packageRoot,
-           List<String> options,
-           this.environment,
-           [this.packageConfig,
-            this.packagesDiscoveryProvider,
-            Backend makeBackend(Compiler compiler)])
+  CompilerImpl(
+      this.provider,
+      api.CompilerOutput outputProvider,
+      this.handler,
+      Uri libraryRoot,
+      this.packageRoot,
+      List<String> options,
+      this.environment,
+      [this.packageConfig,
+       this.packagesDiscoveryProvider,
+       MakeBackendFuncion makeBackend,

[Johnni Winther, 2016/01/21 08:52:58]

MakeBackendFuncion -> MakeBackendFuncion

[ahe, 2016/01/22 11:04:49]

What would be the point of that :-P

[ahe, 2016/01/22 11:58:22]

Fixed in CL 1617183003.

+       MakeReporterFunction makeReporter,
+       MakeDiagnosticOptionsFunction makeDiagnosticOptionsFunction =
+           makeDiagnosticOptions])
       : this.options = options,
         this.platformConfigUri = resolvePlatformConfig(libraryRoot, options),
         super(
             outputProvider: outputProvider,
             enableTypeAssertions: hasOption(options, Flags.enableCheckedMode),
             enableUserAssertions: hasOption(options, Flags.enableCheckedMode),
             trustTypeAnnotations:
                 hasOption(options, Flags.trustTypeAnnotations),
             trustPrimitives:
                 hasOption(options, Flags.trustPrimitives),
@@ skipping 24 matching lines @@
             dumpInfo: hasOption(options, Flags.dumpInfo),
             buildId: extractStringOption(
                 options, '--build-id=',
                 "build number could not be determined"),
             useContentSecurityPolicy:
               hasOption(options, Flags.useContentSecurityPolicy),
             useStartupEmitter: hasOption(options, Flags.fastStartup),
             hasIncrementalSupport:
                 forceIncrementalSupport ||
                 hasOption(options, Flags.incrementalSupport),
-            diagnosticOptions: new DiagnosticOptions(
+            diagnosticOptions: makeDiagnosticOptions(
                 suppressWarnings: hasOption(options, Flags.suppressWarnings),
                 fatalWarnings: hasOption(options, Flags.fatalWarnings),
                 suppressHints: hasOption(options, Flags.suppressHints),
                 terseDiagnostics: hasOption(options, Flags.terse),
                 showPackageWarnings:
                     hasOption(options, Flags.showPackageWarnings)),
             enableExperimentalMirrors:
                 hasOption(options, Flags.enableExperimentalMirrors),
             enableAssertMessage:
                 hasOption(options, Flags.enableAssertMessage),
             generateCodeWithCompileTimeErrors:
                 hasOption(options, Flags.generateCodeWithCompileTimeErrors),
             testMode: hasOption(options, Flags.testMode),
             allowNativeExtensions:
                 hasOption(options, Flags.allowNativeExtensions),
-            makeBackend: makeBackend) {
+            makeBackend: makeBackend,
+            makeReporter: makeReporter) {
     tasks.addAll([
         userHandlerTask = new GenericTask('Diagnostic handler', this),
         userProviderTask = new GenericTask('Input provider', this),
         userPackagesDiscoveryTask =
             new GenericTask('Package discovery', this),
     ]);
     if (libraryRoot == null) {
       throw new ArgumentError("[libraryRoot] is null.");
     }
     if (!libraryRoot.path.endsWith("/")) {
@@ skipping 429 matching lines @@
   Uri lookupLibraryUri(String libraryName) {
     assert(invariant(NO_LOCATION_SPANNABLE,
         sdkLibraries != null, message: "setupSdk() has not been run"));
     return sdkLibraries[libraryName];
   }
 
   Uri resolvePatchUri(String libraryName) {
     return backend.resolvePatchUri(libraryName, platformConfigUri);
   }
 }