anchor.diff:      return runner.run(route: route, shouldBuild: build_arg);
     }
   }
  -
  -Future<int> startApp(
  -  Device device, {
  -  String target,
  -  bool stop: true,
  -  bool install: true,
  -  DebuggingOptions debuggingOptions,
  -  bool traceStartup: false,
  -  bool benchmark: false,
  -  String route,
  -  BuildMode buildMode: BuildMode.debug
  -}) async {
  -  String mainPath = findMainDartFile(target);
  -  if (!FileSystemEntity.isFileSync(mainPath)) {
  -    String message = 'Tried to run $mainPath, but that file does not exist.';
  -    if (target == null)
  -      message += '\nConsider using the -t option to specify the Dart file to start.';
  -    printError(message);
  -    return 1;
  -  }
  -
  -  ApplicationPackage package = getApplicationPackageForPlatform(device.platform);
  -
  -  if (package == null) {
  -    String message = 'No application found for ${device.platform}.';
  -    String hint = getMissingPackageHintForPlatform(device.platform);
  -    if (hint != null)
  -      message += '\n$hint';
  -    printError(message);
  -    return 1;
  -  }
  -
  -  Stopwatch stopwatch = new Stopwatch()..start();
  -
  -  // TODO(devoncarew): We shouldn't have to do type checks here.
  -  if (install && device is AndroidDevice) {
  -    printTrace('Running build command.');
  -
  -    int result = await buildApk(
  -      device.platform,
  -      target: target,
  -      buildMode: buildMode
  -    );
  -
  -    if (result != 0)
  -      return result;
  -  }
  -
  -  // TODO(devoncarew): Move this into the device.startApp() impls. They should
  -  // wait on the stop command to complete before (re-)starting the app. We could
  -  // plumb a Future through the start command from here, but that seems a little
  -  // messy.
  -  if (stop) {
  -    if (package != null) {
  -      printTrace("Stopping app '${package.name}' on ${device.name}.");
  -      await device.stopApp(package);
  -    }
  -  }
  -
  -  // TODO(devoncarew): This fails for ios devices - we haven't built yet.
  -  if (install && device is AndroidDevice) {
  -    printStatus('Installing $package to $device...');
  -
  -    if (!(installApp(device, package, uninstall: false)))
  -      return 1;
  -  }
  -
  -  Map<String, dynamic> platformArgs = <String, dynamic>{};
  -
  -  if (traceStartup != null)
  -    platformArgs['trace-startup'] = traceStartup;
  -
  -  printStatus('Running ${getDisplayPath(mainPath)} on ${device.name}...');
  -
  -  LaunchResult result = await device.startApp(
  -    package,
  -    buildMode,
  -    mainPath: mainPath,
  -    route: route,
  -    debuggingOptions: debuggingOptions,
  -    platformArgs: platformArgs
  -  );
  -
  -  stopwatch.stop();
  -
  -  observatoryPort = result.observatoryPort;
  -
  -
  -  if (!result.started) {
  -    printError('Error running application on ${device.name}.');
  -  } else if (traceStartup) {
  -    try {
  -      VMService observatory = await VMService.connect(result.observatoryPort);
  -      await downloadStartupTrace(observatory);
  -    } catch (error) {
  -      printError('Error downloading trace from observatory: $error');
  -      return 1;
  -    }
  -  }
  -
  -  return result.started ? 0 : 2;
  -}
  
positive.code: 
    RunCommand() {
      Cache.flutterRoot = path.normalize(path.absolute('/Users/lukechurch/GitRepos/flutter'));
  
      // argParser.addFlag('full-restart',
          // defaultsTo: true,
          // help: 'Stop any currently running application process before running the app.');
          fullRestart_arg = true;
  
      // argParser.addFlag('start-paused',
      //     defaultsTo: false,
      //     negatable: false,
      //     help: 'Start in a paused mode and wait for a debugger to connect.');
          startPaused_arg = false;
  
      // argParser.addOption('debug-port',
          // help: 'Listen to the given port for a debug connection (defaults to $kDefaultObservatoryPort).');
          debugPort_arg = kDefaultObservatoryPort;
  
      // argParser.addFlag('build',
          // defaultsTo: true,
          // help: 'If necessary, build the app before running.');
          build_arg = true;
  
  
      // argParser.addOption('use-application-binary',
      //     hide: true,
      //     help: 'Specify a pre-built application binary to use when running.');
      // usesPubOption();
      pub_arg = true;
  
      // Option to enable hot reloading.
      // argParser.addFlag('hot',
      //                   negatable: false,
      //                   defaultsTo: false,
      //                   help: 'Run with support for hot reloading.');
      hot_arg = false;
  
      // Option to write the pid to a file.
      // argParser.addOption('pid-file',
      //                     help: 'Specify a file to write the process id to.'
      //                           'You can send SIGUSR1 to trigger a hot reload '
      //                           'and SIGUSR2 to trigger a full restart.');
      pidFile_arg = null;
  
  
  
      // Hidden option to enable a benchmarking mode. This will run the given
      // application, measure the startup time and the app restart time, write the
      // results out to 'refresh_benchmark.json', and exit. This flag is intended
      // for use in generating automated flutter benchmarks.
      // argParser.addFlag('benchmark', negatable: false, hide: true);
    }
  
    @override
    bool get requiresDevice => true;
  
    @override
    String get usagePath {
      Device device = deviceForCommand;
      String command = hot_arg ? 'hotrun' : name;
      if (device == null)
        return command;
      // Return 'run/ios'.
      return '$command/${getNameForTargetPlatform(device.platform)}';
    }
  
    @override
    void printNoConnectedDevices() {
      super.printNoConnectedDevices();
      if (getCurrentHostPlatform() == HostPlatform.darwin_x64 &&
          XCode.instance.isInstalledAndMeetsVersionCheck) {
        printStatus('');
        printStatus('To run on a simulator, launch it first:');
        printStatus('open -a Simulator.app');
        printStatus('');
      }
    }
  
    @override
    Future<int> runInProject() async {
      int debugPort;
  
      // if (argResults['debug-port'] != null) {
      //   try {
      //     debugPort = int.parse(argResults['debug-port']);
      //   } catch (error) {
      //     printError('Invalid port for `--debug-port`: $error');
      //     return 1;
      //   }
      // }
  
      if (deviceForCommand.isLocalEmulator && !isEmulatorBuildMode(buildMode)) {
        printError('${toTitleCase(getModeName(buildMode))} mode is not supported for emulators.');
        return 1;
  
negative.code: import 'dart:async';
  import 'dart:io';
  
  import 'package:flutter_tools/src/base/common.dart';
  import 'package:flutter_tools/src/base/utils.dart';
  import 'package:flutter_tools/src/build_info.dart';
  