Request bug report if fletch crashes

pkg/fletchc/lib/src/driver/driver_main.dart

 // Copyright (c) 2015, the Fletch 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.md file.
 
 library fletchc.driver_main;
 
 import 'dart:collection' show
     Queue;
 
 import 'dart:io' hide
@@ skipping 62 matching lines @@
 import 'developer.dart' show
     combineTasks,
     allocateWorker;
 
 import 'session_manager.dart' show
     lookupSession;
 
 import '../verbs/create_verb.dart' show
     CreateSessionTask;
 
+import '../please_report_crash.dart' show
+    crashReportRequested,
+    requestBugReportOnOtherCrashMessage;
+
 Function gracefulShutdown;
 
 class DriverCommandTransformerBuilder
     extends CommandTransformerBuilder<Command> {
   Command makeCommand(int commandCode, ByteData payload) {
     DriverCommand code = DriverCommand.values[commandCode];
     switch (code) {
       case DriverCommand.Arguments:
         return new Command(code, decodeArgumentsCommand(payload));
 
@@ skipping 135 matching lines @@
   List<String> arguments = await client.arguments;
   log.gotArguments(arguments);
 
   await handleVerb(arguments, client, pool);
 }
 
 Future<Null> handleVerb(
     List<String> arguments,
     ClientController client,
     IsolatePool pool) async {
+  crashReportRequested = false;
 
   Future<int> performVerb() async {
     client.parseArguments(arguments);
     String sessionName = client.sentence.sessionName;
     UserSession session;
     SharedTask initializer;
     if (sessionName != null) {
       session = lookupSession(sessionName);
       if (session == null) {
         session = await createSession(sessionName, () => allocateWorker(pool));
         // TODO(ahe): packageRoot should be a user configurable option.
         Uri packageRoot = client.sentence.base.resolve('package/');
         initializer = new CreateSessionTask(sessionName, packageRoot);
       }
     }
     DriverVerbContext context =
         new DriverVerbContext(client, pool, session, initializer: initializer);
     return await client.sentence.performVerb(context);
   }
 
   int exitCode = await runGuarded(
       performVerb,
       printLineOnStdout: client.printLineOnStdout,
       handleLateError: client.log.error)
       .catchError(client.reportErrorToClient, test: (e) => e is InputError)
       .catchError((error, StackTrace stackTrace) {
+        if (!crashReportRequested) {
+          client.printLineOnStderr(requestBugReportOnOtherCrashMessage);
+          crashReportRequested = true;
+        }
         client.printLineOnStderr('$error');
         if (stackTrace != null) {
           client.printLineOnStderr('$stackTrace');
         }
         return COMPILER_EXITCODE_CRASH;
       });
 
   if (exitCode != null) {
     client.exit(exitCode);
   }
@@ skipping 135 matching lines @@
     /// [programName] is the canonicalized absolute path to the fletch
     /// executable (the C++ program).
     String programName = sentence.programName;
     String fletchVm = "$programName-vm";
     this.sentence = analyzeSentence(sentence);
     this.fletchVm = fletchVm;
     return this.sentence;
   }
 
   int reportErrorToClient(InputError error, StackTrace stackTrace) {
+    if (!crashReportRequested) {
+      printLineOnStderr(requestBugReportOnOtherCrashMessage);
+      crashReportRequested = true;
+    }
     printLineOnStderr(error.asDiagnostic().formatMessage());
     if (error.kind == DiagnosticKind.internalError) {
       printLineOnStderr('$stackTrace');
       return COMPILER_EXITCODE_CRASH;
     } else {
       return DART_VM_EXITCODE_COMPILE_TIME_ERROR;
     }
   }
 }
 
@@ skipping 11 matching lines @@
   /// A port used to read commands from the worker isolate.
   ReceivePort workerReceivePort;
 
   /// When true, the worker can be shutdown by sending it a
   /// DriverCommand.Signal command.  Otherwise, it must be killed.
   bool eventLoopStarted = false;
 
   /// Subscription for errors from [isolate].
   StreamSubscription errorSubscription;
 
+  bool crashReportRequested = false;
+
   IsolateController(this.isolate);
 
   /// Begin a session with the worker isolate.
   Future<Null> beginSession() async {
     errorSubscription = isolate.errors.listen(null);
     errorSubscription.pause();
     workerReceivePort = isolate.beginSession();
     Stream<Command> workerCommandStream = workerReceivePort.map(
         (message) => new Command(DriverCommand.values[message[0]], message[1]));
     workerCommands = new StreamIterator<Command>(workerCommandStream);
     if (!await workerCommands.moveNext()) {
       // The worker must have been killed, or died in some other way.
       // TODO(ahe): Add this assertion: assert(isolate.wasKilled);
       endSession();
       return;
     }
     Command command = workerCommands.current;
     assert(command.code == DriverCommand.SendPort);
     assert(command.data != null);
     workerSendPort = command.data;
   }
 
   /// Attach to a C++ client and forward commands to the worker isolate, and
   /// vice versa.  The returned future normally completes when the worker
   /// isolate sends DriverCommand.ClosePort, or if the isolate is killed due to
   /// DriverCommand.Signal arriving through client.commands.
   Future<Null> attachClient(ClientController client) async {
+    crashReportRequested = false;
     errorSubscription.onData((errorList) {
       String error = errorList[0];
       String stackTrace = errorList[1];
+      if (!crashReportRequested) {
+        client.printLineOnStderr(requestBugReportOnOtherCrashMessage);
+        crashReportRequested = true;
+      }
       client.printLineOnStderr(error);
       if (stackTrace != null) {
         client.printLineOnStderr(stackTrace);
       }
       workerReceivePort.close();
     });
     errorSubscription.resume();
     handleCommand(Command command) {
       if (command.code == DriverCommand.Signal && !eventLoopStarted) {
         isolate.kill();
@@ skipping 228 matching lines @@
 
   void error(error, StackTrace stackTrace) {
     // TODO(ahe): Modify shutdown verb to report these errors.
     erroneousClients.add(this);
     note("Crash (${arguments.join(' ')}).\n"
          "${stringifyError(error, stackTrace)}");
   }
 
   String toString() => "$id";
 }