Disable printing in kernel-driver

pkg/front_end/lib/src/incremental/kernel_driver.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/api_signature.dart';
 import 'package:front_end/src/base/performace_logger.dart';
+import 'package:front_end/src/fasta/compiler_command_line.dart';
+import 'package:front_end/src/fasta/compiler_context.dart';
 import 'package:front_end/src/fasta/dill/dill_library_builder.dart';
 import 'package:front_end/src/fasta/dill/dill_target.dart';
 import 'package:front_end/src/fasta/kernel/kernel_target.dart';
 import 'package:front_end/src/fasta/kernel/utils.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/uri_translator.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/file_state.dart';
 import 'package:kernel/binary/ast_from_binary.dart';
 import 'package:kernel/kernel.dart' hide Source;
@@ skipping 86 matching lines @@
   /// The [uri] must be absolute and normalized.
   ///
   /// The driver will update the current file state for any file previously
   /// reported using [invalidate].
   ///
   /// If the driver has the cached result for the file with the current file
   /// state, it is returned.
   ///
   /// Otherwise the driver will compute new kernel files and return them.
   Future<KernelResult> getKernel(Uri uri) async {
-    return await _logger.runAsync('Compute delta', () async {
+    return await runWithFrontEndContext('Compute delta', () async {
       await _refreshInvalidatedFiles();
 
       // Ensure that the graph starting at the entry point is ready.
       FileState entryLibrary =
           await _logger.runAsync('Build graph of files', () async {
         return await _fsState.getFile(uri);
       });
 
       List<LibraryCycle> cycles = _logger.run('Compute library cycles', () {
         List<LibraryCycle> cycles = entryLibrary.topologicalOrder;
@@ skipping 12 matching lines @@
           LibraryCycleResult result =
               await _compileCycle(nameRoot, dillTarget, cycle);
           results.add(result);
         }
       });
 
       return new KernelResult(nameRoot, results);
     });
   }
 
+  Future<T> runWithFrontEndContext<T>(String msg, Future<T> f()) async {
+    return await CompilerCommandLine.withGlobalOptions("", [""],

[scheglov, 2017/07/14 15:49:17]

The name CompilerCommandLine does not make sense in KernelDriver.
It not a command line compiler, and Fasta is not a command line compiler.

And in general using global state smells.
This in particular means that we cannot have parallel execution of
KernelDriver(s).
But we might have to, because we create AnalysisDriver (and so will
KernelDriver) for each project in Analysis Server. And because Fasta is
asynchronous, we cannot guarantee that there wouldn't be execution flow switch
from one driver to another.

[Siggi Cherem (dart-lang), 2017/07/14 16:34:04]

Completely agree - this is exactly what I'm working on fixing next: when I say I
want to unify ProcessedOptions and CompilerContext is also to get rid of
CommandLine* objects.
Note that this is actually a misnomer here. Internally this is using a
zone-scope, everything within this call (including async calls) are captured by
a zone that contains the context. It is equivalent to adding a Context argument
and passing it around everywhere.

Today there is a default context, and that's why we didn't notice this so far.
In my refactor I'll get rid of the default context as well, so we know when we
are invoking fasta without a required context (which would be equivalent to not
passing an argument).

To support parallel calls to fasta, that would be completely fine. We can create
and store the context objects separately and reuse them if we are invoking fasta
twice on the same context. If you need to use run fasta with different context
options in parallel, that would also work: each call will have it's own zone
with its own context in scope.

Hope this addresses your concerns. Happy to chat more over VC about this.

+        (CompilerContext context) {
+      context.options.options["--target"] = _target;
+      context.options.options["report"] = (message, severity) {};
+      context.options.options["reportWithoutLocation"] = (message, severity) {};
+      return _logger.runAsync(msg, f);
+    });
+  }
+
   /// The file with the given [uri] might have changed - updated, added, or
   /// removed. Or not, we don't know. Or it might have, but then changed back.
   ///
   /// The [uri] must be absolute and normalized file URI.
   ///
   /// Schedules the file contents for the [uri] to be read into the current
   /// file state prior the next invocation of [getKernel] returns the result.
   ///
   /// Invocation of this method will not prevent a [Future] returned from
   /// [getKernel] from completing with a result, but the result is not
@@ skipping 198 matching lines @@
 
   LibraryCycleResult(this.cycle, this.signature, this.kernelLibraries);
 }
 
 @visibleForTesting
 class _TestView {
   /// The list of [LibraryCycle]s compiled for the last delta.
   /// It does not include libraries which were read from the cache.
   final List<LibraryCycle> compiledCycles = [];
 }