Rename fletch -> dartino

pkg/dartino_compiler/lib/src/verbs/debug_verb.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 fletchc.verbs.debug_verb;
+library dartino_compiler.verbs.debug_verb;
 
 import 'dart:core' hide
     StackTrace;
 
 import 'infrastructure.dart';
 
 import 'dart:async' show
     Stream,
     StreamController,
     StreamIterator;
@@ skipping 10 matching lines @@
 
 import '../worker/developer.dart' show
     ClientEventHandler,
     handleSignal,
     compileAndAttachToVmThen,
     setupClientInOut;
 
 import '../hub/client_commands.dart' show
     ClientCommandCode;
 
-import 'package:fletchc/debug_state.dart' show
+import 'package:dartino_compiler/debug_state.dart' show
     Breakpoint;
 
 import '../../debug_state.dart' show
     RemoteObject,
     RemoteValue,
     BackTrace;
 
 import '../../vm_commands.dart' show
     VmCommand;
 
@@ skipping 196 matching lines @@
 }
 
 Future<int> interactiveDebuggerTask(
     SessionState state,
     Uri base,
     StreamController stdinController) async {
   Session session = state.session;
   if (session == null) {
     throwFatalError(DiagnosticKind.attachToVmBeforeRun);
   }
-  List<FletchDelta> compilationResult = state.compilationResults;
+  List<DartinoDelta> compilationResult = state.compilationResults;
   if (compilationResult.isEmpty) {
     throwFatalError(DiagnosticKind.compileBeforeRun);
   }
 
   // Make sure current state's session is not reused if invoked again.
   state.session = null;
 
-  for (FletchDelta delta in compilationResult) {
+  for (DartinoDelta delta in compilationResult) {
     await session.applyDelta(delta);
   }
 
   Stream<String> inputStream = stdinController.stream
       .transform(UTF8.decoder)
       .transform(new LineSplitter());
 
   return await session.debug(inputStream, base, state);
 }
 
@@ skipping 70 matching lines @@
   if (session == null) {
     throwFatalError(DiagnosticKind.attachToVmBeforeRun);
   }
   state.attachCommandSender(commandSender);
   return session;
 }
 
 Future<int> runToMainDebuggerTask(
     CommandSender commandSender,
     SessionState state) async {
-  List<FletchDelta> compilationResults = state.compilationResults;
+  List<DartinoDelta> compilationResults = state.compilationResults;
   Session session = state.session;
   if (session == null) {
     throwFatalError(DiagnosticKind.attachToVmBeforeRun);
   }
   if (session.loaded) {
     // We cannot reuse a session that has already been loaded. Loading
     // currently implies that some of the code has been run.
     throwFatalError(DiagnosticKind.sessionInvalidState,
         sessionName: state.name);
   }
   if (compilationResults.isEmpty) {
     throwFatalError(DiagnosticKind.compileBeforeRun);
   }
 
   state.attachCommandSender(commandSender);
-  for (FletchDelta delta in compilationResults) {
+  for (DartinoDelta delta in compilationResults) {
     await session.applyDelta(delta);
   }
 
   await session.enableDebugger();
   await session.spawnProcess();
   await session.setBreakpoint(methodName: "main", bytecodeIndex: 0);
   await session.debugRun();
 
   return 0;
 }
@@ skipping 324 matching lines @@
 
   if (argument != 'internal') {
     // TODO(ager, lukechurch): Fix error reporting.
     throwInternalError("Invalid argument to toggle. "
                        "Valid arguments: 'internal'.");
   }
   await session.toggleInternal();
 
   return 0;
 }