Rename fletch -> dartino

tools/testing/dart/dartino_session_command.dart

 // Copyright (c) 2015, the Dartino 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.
 
-/// Provides a [Command] interface for interacting with a Fletch driver session.
+/// Provides a [Command] interface for interacting with a Dartino driver session.
 ///
 /// Normally, this is used by test.dart, but is also has a [main] method that
 /// makes it possible to run a test outside test.dart.
-library test.fletch_session_command;
+library test.dartino_session_command;
 
 import 'dart:async' show
     Completer,
     EventSink,
     Future,
     Stream,
     StreamController,
     StreamTransformer,
     Timer;
 
@@ skipping 10 matching lines @@
     Process,
     ProcessSignal;
 
 import 'test_runner.dart' show
     Command,
     CommandOutputImpl;
 
 import 'decode_exit_code.dart' show
     DecodeExitCode;
 
-import '../../../pkg/fletchc/lib/src/hub/exit_codes.dart' show
+import '../../../pkg/dartino_compiler/lib/src/hub/exit_codes.dart' show
     COMPILER_EXITCODE_CONNECTION_ERROR,
     COMPILER_EXITCODE_CRASH,
     DART_VM_EXITCODE_COMPILE_TIME_ERROR,
     DART_VM_EXITCODE_UNCAUGHT_EXCEPTION;
 
-import '../../../pkg/fletchc/lib/fletch_vm.dart' show
-    FletchVm;
+import '../../../pkg/dartino_compiler/lib/dartino_vm.dart' show
+    DartinoVm;
 
-const String settingsFileNameFlag = "test.fletch_settings_file_name";
+const String settingsFileNameFlag = "test.dartino_settings_file_name";
 const String settingsFileName =
     const String.fromEnvironment(settingsFileNameFlag);
 
 /// Default timeout value (in seconds) used for running commands that are
 /// assumed to complete fast.
 // TODO(ahe): Lower this to 5 seconds.
 const int defaultTimeout = 20;
 
-final Queue<FletchSessionMirror> sessions = new Queue<FletchSessionMirror>();
+final Queue<DartinoSessionMirror> sessions = new Queue<DartinoSessionMirror>();
 
 int sessionCount = 0;
 
-/// Return an available [FletchSessionMirror] or construct a new.
-FletchSessionMirror getAvailableSession() {
+/// Return an available [DartinoSessionMirror] or construct a new.
+DartinoSessionMirror getAvailableSession() {
   if (sessions.isEmpty) {
-    return new FletchSessionMirror(sessionCount++);
+    return new DartinoSessionMirror(sessionCount++);
   } else {
     return sessions.removeFirst();
   }
 }
 
-void returnSession(FletchSessionMirror session) {
+void returnSession(DartinoSessionMirror session) {
   sessions.addLast(session);
 }
 
 String explainExitCode(int code) {
   String exit_message;
   if (code == null) {
     exit_message = "no exit code";
   } else if (code == 0) {
     exit_message = "(success exit code)";
   } else if (code > 0) {
@@ skipping 23 matching lines @@
       exit_message += " (internal error)";
     } else if (code == -2) {
       exit_message += " (control-C)";
     } else {
       exit_message += " (see man 7 signal)";
     }
   }
   return exit_message;
 }
 
-class FletchSessionCommand implements Command {
+class DartinoSessionCommand implements Command {
   final String executable;
   final String script;
   final List<String> arguments;
   final Map<String, String> environmentOverrides;
   final String snapshotFileName;
   final String settingsFileName;
 
-  FletchSessionCommand(
+  DartinoSessionCommand(
       this.executable,
       this.script,
       this.arguments,
       this.environmentOverrides,
       {this.snapshotFileName,
-       this.settingsFileName: ".fletch-settings"});
+       this.settingsFileName: ".dartino-settings"});
 
-  String get displayName => "fletch_session";
+  String get displayName => "dartino_session";
 
   int get maxNumRetries => 0;
 
   String get reproductionCommand {
     var dartVm = Uri.parse(executable).resolve('dart');
-    String fletchPath = Uri.parse(executable).resolve('fletch-vm').toString();
-    String versionFlag = '-Dfletch.version=`$fletchPath --version`';
+    String dartinoPath = Uri.parse(executable).resolve('dartino-vm').toString();
+    String versionFlag = '-Ddartino.version=`$dartinoPath --version`';
     String settingsFileFlag = "-D$settingsFileNameFlag=$settingsFileName";
 
     return """
 
 
 
 There are three ways to reproduce this error:
 
   1. Run the test exactly as in this test framework. This is the hardest to
      debug using gdb:
 
     ${Platform.executable} -c $settingsFileFlag \\
        $versionFlag \\
-       tools/testing/dart/fletch_session_command.dart $executable \\
+       tools/testing/dart/dartino_session_command.dart $executable \\
        ${arguments.join(' ')}
 
 
-  2. Run the helper program `tests/fletchc/run.dart` under `gdb` using
+  2. Run the helper program `tests/dartino_compiler/run.dart` under `gdb` using
      `set follow-fork-mode child`. This can be confusing, but makes it
      easy to run a reproduction command in a loop:
 
     gdb -ex 'set follow-fork-mode child' -ex run --args \\
         $dartVm $settingsFileFlag \\
         $versionFlag \\
-        -c tests/fletchc/run.dart $script
+        -c tests/dartino_compiler/run.dart $script
 
-  3. Run the `fletch-vm` in gdb and attach to it via the helper program. This
+  3. Run the `dartino-vm` in gdb and attach to it via the helper program. This
      is the easiest way to debug using both gdb and lldb. You need to start two
      processes, each in their own terminal window:
 
     gdb -ex run --args $executable-vm --port=54321
 
     $dartVm $settingsFileFlag \\
       $versionFlag \\
-      -c -DattachToVm=54321 tests/fletchc/run.dart $script
+      -c -DattachToVm=54321 tests/dartino_compiler/run.dart $script
 
 
 """;
   }
 
-  Future<FletchTestCommandOutput> run(
+  Future<DartinoTestCommandOutput> run(
       int timeout,
       bool verbose,
       {bool superVerbose: false}) async {
     if (arguments.length > 1) {
       String options = arguments
           .where((String argument) => argument != script)
           .join(' ');
       // TODO(ahe): Passing options to the incremental compiler isn't
       // trivial. We don't want to reset the compiler each time an option
       // changes. For example, when changing the package root, the compiler
       // should refresh all package files to see if they have changed.
       return compilerFail("Compiler options not implemented: $options");
     }
 
-    FletchSessionHelper fletch =
-        new FletchSessionHelper(
+    DartinoSessionHelper dartino =
+        new DartinoSessionHelper(
             getAvailableSession(), executable, environmentOverrides,
             verbose, superVerbose);
 
-    fletch.sessionMirror.printLoggedCommands(fletch.stdout, executable);
+    dartino.sessionMirror.printLoggedCommands(dartino.stdout, executable);
 
     Stopwatch sw = new Stopwatch()..start();
     int exitCode;
     bool endedSession = false;
     try {
       Future vmTerminationFuture;
       try {
-        await fletch.createSession(settingsFileName);
+        await dartino.createSession(settingsFileName);
 
-        // Now that the session is created, start a Fletch VM.
-        String vmSocketAddress = await fletch.spawnVm();
-        // Timeout of the VM is implemented by shutting down the Fletch VM
+        // Now that the session is created, start a Dartino VM.
+        String vmSocketAddress = await dartino.spawnVm();
+        // Timeout of the VM is implemented by shutting down the Dartino VM
         // after [timeout] seconds. This ensures that compilation+runtime never
         // exceed [timeout] seconds (plus whatever time is spent in setting up
         // the session above).
-        vmTerminationFuture = fletch.shutdownVm(timeout);
-        await fletch.runInSession(["attach", "tcp_socket", vmSocketAddress]);
+        vmTerminationFuture = dartino.shutdownVm(timeout);
+        await dartino.runInSession(["attach", "tcp_socket", vmSocketAddress]);
         if (snapshotFileName != null) {
-          exitCode = await fletch.runInSession(
+          exitCode = await dartino.runInSession(
               ["export", script, 'to', 'file', snapshotFileName],
               checkExitCode: false, timeout: timeout);
         } else {
-          exitCode = await fletch.runInSession(["compile", script],
+          exitCode = await dartino.runInSession(["compile", script],
               checkExitCode: false, timeout: timeout);
-          fletch.stderr.writeln("Compilation took: ${sw.elapsed}");
+          dartino.stderr.writeln("Compilation took: ${sw.elapsed}");
           if (exitCode == 0) {
-            exitCode = await fletch.runInSession(
+            exitCode = await dartino.runInSession(
                 ["run", "--terminate-debugger"],
                 checkExitCode: false, timeout: timeout);
           }
         }
       } finally {
         if (exitCode == COMPILER_EXITCODE_CRASH) {
           // If the compiler crashes, chances are that it didn't close the
-          // connection to the Fletch VM. So we kill it.
-          fletch.killVmProcess(ProcessSignal.SIGTERM);
+          // connection to the Dartino VM. So we kill it.
+          dartino.killVmProcess(ProcessSignal.SIGTERM);
         }
         int vmExitCode = await vmTerminationFuture;
-        fletch.stdout.writeln("Fletch VM exitcode is $vmExitCode "
+        dartino.stdout.writeln("Dartino VM exitcode is $vmExitCode "
             "${explainExitCode(vmExitCode)}\n"
-            "Exit code reported by ${fletch.executable} is $exitCode "
+            "Exit code reported by ${dartino.executable} is $exitCode "
             "${explainExitCode(exitCode)}\n");
         if (exitCode == COMPILER_EXITCODE_CONNECTION_ERROR) {
-          fletch.stderr.writeln("Connection error from compiler");
+          dartino.stderr.writeln("Connection error from compiler");
           exitCode = vmExitCode;
         } else if (exitCode != vmExitCode) {
-          if (!fletch.killedVmProcess || vmExitCode == null ||
+          if (!dartino.killedVmProcess || vmExitCode == null ||
               vmExitCode >= 0) {
             throw new UnexpectedExitCode(
-                vmExitCode, "${fletch.executable}-vm", <String>[]);
+                vmExitCode, "${dartino.executable}-vm", <String>[]);
           }
         }
       }
     } on UnexpectedExitCode catch (error) {
-      fletch.stderr.writeln("$error");
+      dartino.stderr.writeln("$error");
       exitCode = combineExitCodes(exitCode, error.exitCode);
       try {
         if (!endedSession) {
           // TODO(ahe): Only end if there's a crash.
           endedSession = true;
-          await fletch.run(["x-end", "session", fletch.sessionName]);
+          await dartino.run(["x-end", "session", dartino.sessionName]);
         }
       } on UnexpectedExitCode catch (error) {
-        fletch.stderr.writeln("$error");
+        dartino.stderr.writeln("$error");
         // TODO(ahe): Error ignored, long term we should be able to guarantee
         // that shutting down a session never leads to an error.
       }
     }
 
     if (exitCode == null) {
       exitCode = COMPILER_EXITCODE_CRASH;
-      fletch.stdout.writeln(
+      dartino.stdout.writeln(
           '**test.py** could not determine a good exitcode, using $exitCode.');
     }
 
     if (endedSession) {
-      returnSession(new FletchSessionMirror(fletch.sessionMirror.id));
+      returnSession(new DartinoSessionMirror(dartino.sessionMirror.id));
     } else {
-      returnSession(fletch.sessionMirror);
+      returnSession(dartino.sessionMirror);
     }
 
-    return new FletchTestCommandOutput(
-        this, exitCode, fletch.hasTimedOut,
-        fletch.combinedStdout, fletch.combinedStderr, sw.elapsed, -1);
+    return new DartinoTestCommandOutput(
+        this, exitCode, dartino.hasTimedOut,
+        dartino.combinedStdout, dartino.combinedStderr, sw.elapsed, -1);
   }
 
-  FletchTestCommandOutput compilerFail(String message) {
-    return new FletchTestCommandOutput(
+  DartinoTestCommandOutput compilerFail(String message) {
+    return new DartinoTestCommandOutput(
         this, DART_VM_EXITCODE_COMPILE_TIME_ERROR, false, <int>[],
         UTF8.encode(message), const Duration(seconds: 0), -1);
   }
 
   String toString() => reproductionCommand;
 
   set displayName(_) => throw "not supported";
 
   get commandLine => throw "not supported";
   set commandLine(_) => throw "not supported";
 
   get outputIsUpToDate => throw "not supported";
 }
 
-/// [compiler] is assumed to be coming from `fletch` in which case
+/// [compiler] is assumed to be coming from `dartino` in which case
 /// [COMPILER_EXITCODE_CRASH], [DART_VM_EXITCODE_COMPILE_TIME_ERROR], and
 /// [DART_VM_EXITCODE_UNCAUGHT_EXCEPTION] all represent a compiler crash.
 ///
-/// [runtime] is assumed to be coming from `fletch-vm` in which case which case
+/// [runtime] is assumed to be coming from `dartino-vm` in which case which case
 /// [DART_VM_EXITCODE_COMPILE_TIME_ERROR], and
 /// [DART_VM_EXITCODE_UNCAUGHT_EXCEPTION] is just the result of running a test
 /// that has an error (not a crash).
 int combineExitCodes(int compiler, int runtime) {
   if (compiler == null) return runtime;
 
   if (runtime == null) return compiler;
 
   switch (compiler) {
     case COMPILER_EXITCODE_CRASH:
@@ skipping 22 matching lines @@
   final List<String> arguments;
 
   UnexpectedExitCode(this.exitCode, this.executable, this.arguments);
 
   String toString() {
     return "Non-zero exit code ($exitCode) from: "
         "$executable ${arguments.join(' ')}";
   }
 }
 
-class FletchTestCommandOutput extends CommandOutputImpl with DecodeExitCode {
-  FletchTestCommandOutput(
+class DartinoTestCommandOutput extends CommandOutputImpl with DecodeExitCode {
+  DartinoTestCommandOutput(
       Command command,
       int exitCode,
       bool timedOut,
       List<int> stdout,
       List<int> stderr,
       Duration time,
       int pid)
       : super(command, exitCode, timedOut, stdout, stderr, time, false, pid);
 }
 
@@ skipping 41 matching lines @@
 
   void writeText(String text) {
     add(UTF8.encode(text));
   }
 
   void close() {
     verboseSink.close();
   }
 }
 
-class FletchSessionHelper {
+class DartinoSessionHelper {
   final String executable;
 
-  final FletchSessionMirror sessionMirror;
+  final DartinoSessionMirror sessionMirror;
 
   final String sessionName;
 
   final Map<String, String> environmentOverrides;
 
   final bool isVerbose;
 
   final BytesOutputSink stdout;
 
   final BytesOutputSink stderr;
 
   final BytesOutputSink vmStdout;
 
   final BytesOutputSink vmStderr;
 
   Process vmProcess;
 
   Future<int> vmExitCodeFuture;
 
   bool killedVmProcess = false;
 
   bool hasTimedOut = false;
 
-  FletchSessionHelper(
-      FletchSessionMirror sessionMirror,
+  DartinoSessionHelper(
+      DartinoSessionMirror sessionMirror,
       this.executable,
       this.environmentOverrides,
       this.isVerbose,
       bool superVerbose)
       : sessionMirror = sessionMirror,
         sessionName = sessionMirror.makeSessionName(),
         stdout = new BytesOutputSink(superVerbose),
         stderr = new BytesOutputSink(superVerbose),
         vmStdout = new BytesOutputSink(superVerbose),
         vmStderr = new BytesOutputSink(superVerbose);
@@ skipping 43 matching lines @@
         .listen(stderr.add)
         .asFuture();
     await process.stdin.close();
 
     // Can't reuse [hasTimedOut] as we don't want to throw when calling 'x-end'
     // in the finally block above.
     bool thisCommandTimedout = false;
 
     int exitCode = await exitCodeWithTimeout(process, timeout, () {
       stdout.writeln(
-          "\n=> Reached command timeout (sent SIGTERM to fletch-vm)");
+          "\n=> Reached command timeout (sent SIGTERM to dartino-vm)");
       thisCommandTimedout = true;
       hasTimedOut = true;
       if (vmProcess != null) {
         killedVmProcess = vmProcess.kill(ProcessSignal.SIGTERM);
       }
     });
     await stdoutFuture;
     await stderrFuture;
 
     stdout.writeln("\n => $exitCode ${explainExitCode(exitCode)}\n");
@@ skipping 18 matching lines @@
     if (sessionMirror.isCreated) {
       return 0;
     } else {
       sessionMirror.isCreated = true;
       return await run(
           ["create", "session", sessionName, "with", settingsFileName]);
     }
   }
 
   Future<String> spawnVm() async {
-    FletchVm fletchVm = await FletchVm.start(
+    DartinoVm dartinoVm = await DartinoVm.start(
         "$executable-vm", environment: environmentOverrides);
-    vmProcess = fletchVm.process;
+    vmProcess = dartinoVm.process;
     String commandDescription = "$executable-vm";
     if (isVerbose) {
       print("Running $commandDescription");
     }
     String commandDescriptionForLog = "\$ $commandDescription";
     vmStdout.writeln(commandDescriptionForLog);
     stdout.writeln('$commandDescriptionForLog &');
 
     Future stdoutFuture =
-        fletchVm.stdoutLines.listen(vmStdout.writeln).asFuture();
+        dartinoVm.stdoutLines.listen(vmStdout.writeln).asFuture();
     bool isFirstStderrLine = true;
     Future stderrFuture =
-        fletchVm.stderrLines.listen(
+        dartinoVm.stderrLines.listen(
             (String line) {
               if (isFirstStderrLine) {
                 vmStdout.writeln(commandDescriptionForLog);
                 isFirstStderrLine = false;
               }
               vmStdout.writeln(line);
             })
         .asFuture();
 
-    vmExitCodeFuture = fletchVm.exitCode.then((int exitCode) async {
-      if (isVerbose) print("Exiting Fletch VM with exit code $exitCode.");
+    vmExitCodeFuture = dartinoVm.exitCode.then((int exitCode) async {
+      if (isVerbose) print("Exiting Dartino VM with exit code $exitCode.");
       await stdoutFuture;
-      if (isVerbose) print("Stdout of Fletch VM process closed.");
+      if (isVerbose) print("Stdout of Dartino VM process closed.");
       await stderrFuture;
-      if (isVerbose) print("Stderr of Fletch VM process closed.");
+      if (isVerbose) print("Stderr of Dartino VM process closed.");
       return exitCode;
     });
 
-    return "${fletchVm.host}:${fletchVm.port}";
+    return "${dartinoVm.host}:${dartinoVm.port}";
   }
 
-  /// Returns a future that completes when the fletch VM exits using
+  /// Returns a future that completes when the dartino VM exits using
   /// [exitCodeWithTimeout] to ensure termination within [timeout] seconds.
   Future<int> shutdownVm(int timeout) async {
     await exitCodeWithTimeout(vmProcess, timeout, () {
       stdout.writeln(
-          "\n**fletch-vm** Reached total timeout (sent SIGTERM to fletch-vm)");
+          "\n**dartino-vm** Reached total timeout (sent SIGTERM to dartino-vm)");
       killedVmProcess = true;
       hasTimedOut = true;
     });
     return vmExitCodeFuture;
   }
 
   void killVmProcess(ProcessSignal signal) {
     if (vmProcess == null) return;
     killedVmProcess = vmProcess.kill(ProcessSignal.SIGTERM);
   }
@@ skipping 32 matching lines @@
   }
 
   timer = new Timer(new Duration(seconds: timeout), firstTimeout);
 
   int exitCode = await process.exitCode;
   done = true;
   timer.cancel();
   return exitCode;
 }
 
-/// Represents a session in the persistent Fletch client process.
-class FletchSessionMirror {
+/// Represents a session in the persistent Dartino client process.
+class DartinoSessionMirror {
   static const int RINGBUFFER_SIZE = 15;
 
   final int id;
 
   final Queue<List<String>> internalLoggedCommands = new Queue<List<String>>();
 
   bool isCreated = false;
 
-  FletchSessionMirror(this.id);
+  DartinoSessionMirror(this.id);
 
   void logCommand(List<String> command) {
     internalLoggedCommands.add(command);
     if (internalLoggedCommands.length >= RINGBUFFER_SIZE) {
       internalLoggedCommands.removeFirst();
     }
   }
 
   void printLoggedCommands(BytesOutputSink sink, String executable) {
     sink.writeln("Previous commands in this session:");
@@ skipping 13 matching lines @@
 
 Future<Null> main(List<String> arguments) async {
   // Setting [sessionCount] to the current time in milliseconds ensures that it
   // is highly unlikely that reproduction commands conflicts with an existing
   // session in a persistent process that wasn't killed.
   sessionCount = new DateTime.now().millisecondsSinceEpoch;
   String executable = arguments.first;
   String script = arguments[1];
   arguments = arguments.skip(2).toList();
   Map<String, String> environmentOverrides = <String, String>{};
-  FletchSessionCommand command = new FletchSessionCommand(
+  DartinoSessionCommand command = new DartinoSessionCommand(
       executable, script, arguments, environmentOverrides,
       settingsFileName: settingsFileName);
-  FletchTestCommandOutput output =
+  DartinoTestCommandOutput output =
       await command.run(0, true, superVerbose: true);
   print("Test outcome: ${output.decodeExitCode()}");
 }