Update incremental load example so you can point to different sdk

pkg/front_end/example/incremental_reload/run.dart

 // Copyright (c) 2017, the Dart 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 file.
 
 /// Example that illustrates how to use the incremental compiler and trigger a
 /// hot-reload on the VM after recompiling the application.
 ///
 /// This example resembles the `run` command in flutter-tools. It creates an
 /// interactive command-line program that waits for the user to tap a key to
 /// trigger a recompile and reload.
@@ skipping 28 matching lines @@
 ///
 ///   * In terminal A, hit the "r" key to trigger a recompile and hot reload.
 ///
 ///   * See the changed program in terminal B
 library front_end.example.incremental_reload.run;
 
 import 'dart:io';
 import 'dart:async';
 import 'dart:convert' show ASCII;
 
+import 'package:args/args.dart';
+import 'package:kernel/target/targets.dart';
+
 import '../../tool/vm/reload.dart';
 
 import 'compiler_with_invalidation.dart';
 
+ArgParser argParser = new ArgParser(allowTrailingOptions: true)
+  ..addOption('sdk-root', help: 'Path to sdk for compilation')
+  ..addOption('output',
+      help: 'Output dill file', defaultsTo: 'out.dill', abbr: 'o')
+  ..addOption('target',
+      help: 'One of none, vm, vm_fasta, vmcc, vmreify, flutter, flutter_fasta',
+      defaultsTo: 'vm');
+
+String usage = '''
+Usage: dart [options] input.dart
+
+Runs console-driven incremental compiler.
+
+Options:
+${argParser.usage}
+''';
+
 RemoteVm remoteVm = new RemoteVm();
 AnsiTerminal terminal = new AnsiTerminal();
 
 main(List<String> args) async {
-  if (args.length <= 1) {
-    print('usage: dart incremental_compile.dart input.dart out.dill');
+  ArgResults options = argParser.parse(args);
+  if (options.rest.isEmpty) {
+    print('Need an input file');
+    print(usage);
     exit(1);
   }
 
-  var compiler = await createIncrementalCompiler(args[0]);
-  var outputUri = Uri.base.resolve(args[1]);
+  var compiler = await createIncrementalCompiler(options.rest[0],
+      sdkRoot:
+          options['sdk-root'] != null ? Uri.parse(options['sdk-root']) : null,
+      target: targets[options['target']](new TargetFlags()));
+  var outputUri = Uri.base.resolve(options['output']);
 
   showHeader();
   listenOnKeyPress(compiler, outputUri)
       .whenComplete(() => remoteVm.disconnect());
 }
 
 /// Implements the interactive UI by listening for input keys from the user.
 Future listenOnKeyPress(IncrementalCompiler compiler, Uri outputUri) {
   var completer = new Completer();
   terminal.singleCharMode = true;
   StreamSubscription subscription;
   subscription = terminal.onCharInput.listen((String char) async {
     try {
       CompilationResult compilationResult;
       ReloadResult reloadResult;
-      switch (char) {
+      switch (char.trim()) {
         case 'r':
           compilationResult = await rebuild(compiler, outputUri);
           if (!compilationResult.errorSeen &&
               compilationResult.program != null &&
               compilationResult.program.libraries.isNotEmpty) {
             reloadResult = await reload(outputUri);
           }
           break;
         case 'c':
           compilationResult = await rebuild(compiler, outputUri);
@@ skipping 145 matching lines @@
   /// Setting the line mode can throw for some terminals (with "Operation not
   /// supported on socket"), but the error can be safely ignored.
   static const List<int> _lineModeIgnorableErrors = const <int>[
     _ENXIO,
     _ENOTTY,
     _ENETRESET,
     _INVALID_HANDLE,
   ];
 
   String bolden(String message) => wrap(message, _bold);
+
   String green(String message) => wrap(message, _green);
+
   String red(String message) => wrap(message, _red);
 
   String wrap(String message, String escape) {
     final StringBuffer buffer = new StringBuffer();
     for (String line in message.split('\n'))
       buffer.writeln('$escape$line$_reset');
     final String result = buffer.toString();
     // avoid introducing a new newline to the emboldened text
     return (!message.endsWith('\n') && result.endsWith('\n'))
         ? result.substring(0, result.length - 1)
@@ skipping 19 matching lines @@
     } on StdinException catch (error) {
       if (!_lineModeIgnorableErrors.contains(error.osError?.errorCode)) rethrow;
     }
   }
 
   /// Return keystrokes from the console.
   ///
   /// Useful when the console is in [singleCharMode].
   Stream<String> get onCharInput => stdin.transform(ASCII.decoder);
 }