Rename fletch -> dartino

pkg/dartino_compiler/lib/vm_session.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.
 
-library fletch.vm_session;
+library dartino.vm_session;
 
 import 'dart:core';
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io' hide exit;
 
 import 'dart:typed_data' show
     ByteData,
     Uint8List;
 
 import 'vm_commands.dart';
-import 'fletch_system.dart';
+import 'dartino_system.dart';
 
-import 'incremental/fletchc_incremental.dart'
+import 'incremental/dartino_compiler_incremental.dart'
     show IncrementalCompiler;
 
 import 'src/codegen_visitor.dart';
 import 'src/debug_info.dart';
 
 // TODO(ahe): Get rid of this import.
-import 'src/fletch_backend.dart' show FletchBackend;
+import 'src/dartino_backend.dart' show DartinoBackend;
 
-import 'src/fletch_selector.dart' show
-    FletchSelector,
+import 'src/dartino_selector.dart' show
+    DartinoSelector,
     SelectorKind;
 
 import 'debug_state.dart';
 
 import 'src/shared_command_infrastructure.dart' show
     CommandTransformerBuilder,
     toUint8ListView;
 
 import 'src/hub/session_manager.dart' show
     SessionState;
 
 part 'vm_command_reader.dart';
 part 'input_handler.dart';
 
-/// Encapsulates a TCP connection to a running fletch-vm and provides a
+/// Encapsulates a TCP connection to a running dartino-vm and provides a
 /// [VmCommand] based view on top of it.
-class FletchVmSession {
-  /// The outgoing connection to the fletch-vm.
+class DartinoVmSession {
+  /// The outgoing connection to the dartino-vm.
   final StreamSink<List<int>> _outgoingSink;
 
   final Sink<List<int>> stdoutSink;
   final Sink<List<int>> stderrSink;
 
   /// The VM command reader reads data from the vm, converts the data
   /// into a [VmCommand], and provides a stream iterator iterating over
   /// these commands.
   /// If the [VmCommand] is for stdout or stderr the reader automatically
   /// forwards them to the stdout/stderr sinks and does not add them to the
@@ skipping 14 matching lines @@
   /// golden files.
   bool hideRawIds = false;
 
   /// When true, don't use colors to highlight focus when printing code.
   /// This is currently only true when running tests to avoid having to deal
   /// with color control characters in the expected files.
   bool colorsDisabled = false;
 
   VmCommand connectionError = new ConnectionError("Connection is closed", null);
 
-  FletchVmSession(Socket vmSocket,
+  DartinoVmSession(Socket vmSocket,
                   Sink<List<int>> stdoutSink,
                   Sink<List<int>> stderrSink)
       : _outgoingSink = vmSocket,
         this.stdoutSink = stdoutSink,
         this.stderrSink = stderrSink,
         _done = vmSocket.done,
         _commandReader = new VmCommandReader(vmSocket, stdoutSink, stderrSink) {
     _done.catchError((_, __) {}).then((_) {
       _connectionIsDead = true;
     });
   }
 
   void writeStdout(String s) {
     if (!silent && stdoutSink != null) stdoutSink.add(UTF8.encode(s));
   }
 
   void writeStdoutLine(String s) => writeStdout("$s\n");
 
   /// Convenience around [runCommands] for running just a single command.
   Future<VmCommand> runCommand(VmCommand command) {
     return runCommands([command]);
   }
 
-  /// Sends the given commands to a fletch-vm and reads response commands
+  /// Sends the given commands to a dartino-vm and reads response commands
   /// (if necessary).
   ///
   /// If all commands have been successfully applied and responses been awaited,
   /// this function will complete with the last received [VmCommand] from the
   /// remote peer (or `null` if there was none).
   Future<VmCommand> runCommands(List<VmCommand> commands) async {
     if (commands.any((VmCommand c) => c.numberOfResponsesExpected == null)) {
       throw new ArgumentError(
           'The runComands() method will read response commands and therefore '
           'needs to know how many to read. One of the given commands does'
           'not specify how many commands the response will have.');
     }
 
     VmCommand lastResponse;
     for (VmCommand command in commands) {
       await sendCommand(command);
       for (int i = 0; i < command.numberOfResponsesExpected; i++) {
         lastResponse = await readNextCommand();
       }
     }
     return lastResponse;
   }
 
-  /// Sends all given [VmCommand]s to a fletch-vm.
+  /// Sends all given [VmCommand]s to a dartino-vm.
   Future sendCommands(List<VmCommand> commands) async {
     for (var command in commands) {
       await sendCommand(command);
     }
   }
 
-  /// Sends a [VmCommand] to a fletch-vm.
+  /// Sends a [VmCommand] to a dartino-vm.
   Future sendCommand(VmCommand command) async {
     if (_connectionIsDead) {
       throw new StateError(
-          'Trying to send command ${command} to fletch-vm, but '
+          'Trying to send command ${command} to dartino-vm, but '
           'the connection is already closed.');
     }
     command.addTo(_outgoingSink);
   }
 
-  /// Will read the next [VmCommand] the fletch-vm sends to us.
+  /// Will read the next [VmCommand] the dartino-vm sends to us.
   Future<VmCommand> readNextCommand({bool force: true}) async {
     if (_drainedIncomingCommands) {
       return connectionError;
     }
 
     _drainedIncomingCommands = !await _commandReader.iterator.moveNext()
         .catchError((error, StackTrace trace) {
           connectionError = new ConnectionError(error, trace);
           return false;
         });
 
     if (_drainedIncomingCommands && force) {
       return connectionError;
     }
 
     return _commandReader.iterator.current;
   }
 
-  /// Closes the connection to the fletch-vm and drains the remaining response
+  /// Closes the connection to the dartino-vm and drains the remaining response
   /// commands.
   ///
   /// If [ignoreExtraCommands] is `false` it will throw a StateError if the
-  /// fletch-vm sent any commands.
+  /// dartino-vm sent any commands.
   Future shutdown({bool ignoreExtraCommands: false}) async {
     await _outgoingSink.close().catchError((_) {});
 
     while (!_drainedIncomingCommands) {
       VmCommand response = await readNextCommand(force: false);
       if (!ignoreExtraCommands && response != null) {
         await kill();
         throw new StateError(
-            "Got unexpected command from fletch-vm during shutdown "
+            "Got unexpected command from dartino-vm during shutdown "
             "($response)");
       }
     }
 
     return _done;
   }
 
   Future interrupt() {
     return sendCommand(const ProcessDebugInterrupt());
   }
 
-  /// Closes the connection to the fletch-vm. It does not wait until it shuts
+  /// Closes the connection to the dartino-vm. It does not wait until it shuts
   /// down.
   ///
   /// This method will never complete with an exception.
   Future kill() async {
     _connectionIsDead = true;
     _drainedIncomingCommands = true;
 
     await _outgoingSink.close().catchError((_) {});
     var value = _commandReader.iterator.cancel();
     if (value != null) {
       await value.catchError((_) {});
     }
     _drainedIncomingCommands = true;
   }
 }
 
-/// Extends a bare [FletchVmSession] with debugging functionality.
-class Session extends FletchVmSession {
+/// Extends a bare [DartinoVmSession] with debugging functionality.
+class Session extends DartinoVmSession {
   final IncrementalCompiler compiler;
   final Future processExitCodeFuture;
 
   DebugState debugState;
-  FletchSystem fletchSystem;
+  DartinoSystem dartinoSystem;
   bool loaded = false;
   bool running = false;
   bool terminated = false;
 
-  Session(Socket fletchVmSocket,
+  Session(Socket dartinoVmSocket,
           this.compiler,
           Sink<List<int>> stdoutSink,
           Sink<List<int>> stderrSink,
           [this.processExitCodeFuture])
-      : super(fletchVmSocket, stdoutSink, stderrSink) {
+      : super(dartinoVmSocket, stdoutSink, stderrSink) {
     // We send many small packages, so use no-delay.
-    fletchVmSocket.setOption(SocketOption.TCP_NODELAY, true);
+    dartinoVmSocket.setOption(SocketOption.TCP_NODELAY, true);
     // TODO(ajohnsen): Should only be initialized on debug()/testDebugger().
     debugState = new DebugState(this);
   }
 
-  Future applyDelta(FletchDelta delta) async {
+  Future applyDelta(DartinoDelta delta) async {
     VmCommand response = await runCommands(delta.commands);
-    fletchSystem = delta.system;
+    dartinoSystem = delta.system;
     return response;
   }
 
   Future<HandShakeResult> handShake(String version) async {
     VmCommand command = await runCommand(new HandShake(version));
     if (command != null && command is HandShakeResult) return command;
     return null;
   }
 
   Future disableVMStandardOutput() async {
@@ skipping 14 matching lines @@
   Future spawnProcess() async {
     await runCommand(const ProcessSpawnForMain());
   }
 
   Future run() async {
     await spawnProcess();
     loaded = true;
     await runCommand(const ProcessRun());
     // NOTE: The [ProcessRun] command normally results in a
     // [ProcessTerminated] command. But if the compiler emitted a compile time
-    // error, the fletch-vm will just halt()/exit() and we therefore get no
+    // error, the dartino-vm will just halt()/exit() and we therefore get no
     // response.
     var command = await readNextCommand(force: false);
     if (command != null && command is! ProcessTerminated) {
       throw new Exception('Expected process to finish complete with '
                           '[ProcessTerminated] but got [$command]');
     }
     await shutdown();
   }
 
   Future<int> debug(
@@ skipping 33 matching lines @@
 
       case VmCommandCode.ConnectionError:
         running = false;
         loaded = false;
         await shutdown();
         terminated = true;
         break;
 
       case VmCommandCode.ProcessBreakpoint:
         ProcessBreakpoint command = response;
-        var function = fletchSystem.lookupFunctionById(command.functionId);
+        var function = dartinoSystem.lookupFunctionById(command.functionId);
         debugState.topFrame = new BackTraceFrame(
             function, command.bytecodeIndex, compiler, debugState);
         running = true;
         break;
 
       default:
         throw new StateError(
-            "Unhandled response from Fletch VM connection: ${response.code}");
+            "Unhandled response from Dartino VM connection: ${response.code}");
 
     }
     return response;
   }
 
   Future<VmCommand> debugRun() async {
     assert(!loaded);
     assert(!running);
     loaded = true;
     running = true;
     await sendCommand(const ProcessRun());
     return handleProcessStop(await readNextCommand());
   }
 
   Future setBreakpointHelper(String name,
-                             FletchFunction function,
+                             DartinoFunction function,
                              int bytecodeIndex) async {
     ProcessSetBreakpoint response = await runCommands([
         new PushFromMap(MapId.methods, function.functionId),
         new ProcessSetBreakpoint(bytecodeIndex),
     ]);
     int breakpointId = response.value;
     var breakpoint = new Breakpoint(name, bytecodeIndex, breakpointId);
     debugState.breakpoints[breakpointId] = breakpoint;
     return breakpoint;
   }
 
   // TODO(ager): Let setBreakpoint return a stream instead and deal with
   // error situations such as bytecode indices that are out of bounds for
   // some of the methods with the given name.
   Future setBreakpoint({String methodName, int bytecodeIndex}) async {
-    Iterable<FletchFunction> functions =
-        fletchSystem.functionsWhere((f) => f.name == methodName);
+    Iterable<DartinoFunction> functions =
+        dartinoSystem.functionsWhere((f) => f.name == methodName);
     List<Breakpoint> breakpoints = [];
-    for (FletchFunction function in functions) {
+    for (DartinoFunction function in functions) {
       breakpoints.add(
           await setBreakpointHelper(methodName, function, bytecodeIndex));
     }
     return breakpoints;
   }
 
   Future setFileBreakpointFromPosition(String name,
                                        Uri file,
                                        int position) async {
     if (position == null) {
       return null;
     }
     DebugInfo debugInfo = compiler.debugInfoForPosition(
         file,
         position,
-        fletchSystem);
+        dartinoSystem);
     if (debugInfo == null) {
       return null;
     }
     SourceLocation location = debugInfo.locationForPosition(position);
     if (location == null) {
       return null;
     }
-    FletchFunction function = debugInfo.function;
+    DartinoFunction function = debugInfo.function;
     int bytecodeIndex = location.bytecodeIndex;
     return setBreakpointHelper(function.name, function, bytecodeIndex);
   }
 
   Future setFileBreakpointFromPattern(Uri file,
                                       int line,
                                       String pattern) async {
     assert(line > 0);
     int position = compiler.positionInFileFromPattern(file, line - 1, pattern);
     return setFileBreakpointFromPosition(
@@ skipping 147 matching lines @@
     debugState.currentFrame = frame;
     return true;
   }
 
   BackTrace stackTraceFromBacktraceResponse(
       ProcessBacktrace backtraceResponse) {
     int frames = backtraceResponse.frames;
     BackTrace stackTrace = new BackTrace(frames, debugState);
     for (int i = 0; i < frames; ++i) {
       int functionId = backtraceResponse.functionIds[i];
-      FletchFunction function = fletchSystem.lookupFunctionById(functionId);
+      DartinoFunction function = dartinoSystem.lookupFunctionById(functionId);
       if (function == null) {
-        function = const FletchFunction.missing();
+        function = const DartinoFunction.missing();
       }
       stackTrace.addFrame(
           compiler,
           new BackTraceFrame(function,
                          backtraceResponse.bytecodeIndices[i],
                          compiler,
                          debugState));
     }
     return stackTrace;
  }
@@ skipping 57 matching lines @@
   Future<BackTrace> processStack(int processId) async {
     assert(running);
     ProcessBacktrace backtraceResponse =
       await runCommand(new ProcessBacktraceRequest(processId));
     return stackTraceFromBacktraceResponse(backtraceResponse);
   }
 
   String dartValueToString(DartValue value) {
     if (value is Instance) {
       Instance i = value;
-      String className = fletchSystem.lookupClassById(i.classId).name;
+      String className = dartinoSystem.lookupClassById(i.classId).name;
       return "Instance of '$className'";
     } else {
       return value.dartToString();
     }
   }
 
   String instanceStructureToString(InstanceStructure structure,
                                    List<DartValue> fields) {
     int classId = structure.classId;
-    FletchClass klass = fletchSystem.lookupClassById(classId);
+    DartinoClass klass = dartinoSystem.lookupClassById(classId);
 
-    // TODO(fletchc-team): This should be more strict and a compiler bug
+    // TODO(dartino_compiler-team): This should be more strict and a compiler bug
     // should be reported to the user in order for us to get a bugreport.
     if (klass == null) {
-      return 'Unknown (Fletch compiler was unable to find exception class)';
+      return 'Unknown (Dartino compiler was unable to find exception class)';
     }
 
     StringBuffer sb = new StringBuffer();
     sb.writeln("Instance of '${klass.name}' {");
     for (int i = 0; i < structure.fields; i++) {
       DartValue value = fields[i];
       String fieldName = debugState.lookupFieldName(klass, i);
       if (fieldName == null) {
         fieldName = '<unnamed>';
       }
       sb.writeln('  $fieldName: ${dartValueToString(value)}');
     }
     sb.write('}');
     return '$sb';
   }
 
   String noSuchMethodErrorToString(List<DartValue> nsmFields) {
     assert(nsmFields.length == 3);
     DartValue receiver = nsmFields[0];
     ClassValue receiverClass = nsmFields[1];
     Integer receiverSelector = nsmFields[2];
-    FletchSelector selector = new FletchSelector(receiverSelector.value);
+    DartinoSelector selector = new DartinoSelector(receiverSelector.value);
 
     String method =
-        fletchSystem.lookupSymbolBySelector(selector.encodedSelector);
-    FletchClass klass = fletchSystem.lookupClassById(receiverClass.classId);
-    // TODO(ahe): If FletchClass is a synthetic closure class, improve the
+        dartinoSystem.lookupSymbolBySelector(selector.encodedSelector);
+    DartinoClass klass = dartinoSystem.lookupClassById(receiverClass.classId);
+    // TODO(ahe): If DartinoClass is a synthetic closure class, improve the
     // message. For example, "(local) function `foo` takes 3 arguments, but
     // called with 4" instead of "Class '<internal>' has no method named 'call'
     // that takes 4 arguments".
     String name = klass.name;
     String raw = hideRawIds
         ? "" : " (${receiverClass.classId}::${selector.encodedSelector})";
     // TODO(ahe): Lookup the name in the receiverClass and include that as a
     // suggestion in the error mesage.
     switch (selector.kind) {
       case SelectorKind.Method:
@@ skipping 19 matching lines @@
     return fields;
   }
 
   String exceptionToString(RemoteObject exception) {
     String message;
     if (exception is RemoteValue) {
       message = dartValueToString(exception.value);
     } else if (exception is RemoteInstance) {
       InstanceStructure structure = exception.instance;
       int classId = structure.classId;
-      FletchClass klass = fletchSystem.lookupClassById(classId);
+      DartinoClass klass = dartinoSystem.lookupClassById(classId);
 
-      FletchBackend backend = compiler.compiler.backend;
-      var fletchNoSuchMethodErrorClass = fletchSystem.lookupClassByElement(
-          backend.fletchNoSuchMethodErrorClass);
+      DartinoBackend backend = compiler.compiler.backend;
+      var dartinoNoSuchMethodErrorClass = dartinoSystem.lookupClassByElement(
+          backend.dartinoNoSuchMethodErrorClass);
 
-      if (klass == fletchNoSuchMethodErrorClass) {
+      if (klass == dartinoNoSuchMethodErrorClass) {
         message = noSuchMethodErrorToString(exception.fields);
       } else {
         message = instanceStructureToString(
             exception.instance, exception.fields);
       }
     } else {
       throw new UnimplementedError();
     }
     return 'Uncaught exception: $message';
   }
@@ skipping 123 matching lines @@
       return '';
     } else if (response is ProcessTerminated) {
       return '### process terminated\n';
 
     } else if (response is ConnectionError) {
       return '### lost connection to the virtual machine\n';
     }
     return '';
   }
 }