fixes #610, incorrect help output

lib/src/compiler/command.dart

 // Copyright (c) 2016, 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.
 
 import 'dart:convert' show JSON;
 import 'dart:io';
-import 'package:args/command_runner.dart';
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/summary/package_bundle_reader.dart'
     show InSummarySource;
+import 'package:args/args.dart' show ArgParser, ArgResults;
+import 'package:args/command_runner.dart' show UsageException;
+import 'package:path/path.dart' as path;
+
 import 'compiler.dart'
     show BuildUnit, CompilerOptions, JSModuleFile, ModuleCompiler;
 import '../analyzer/context.dart' show AnalyzerOptions;
-import 'package:path/path.dart' as path;
 
 typedef void MessageHandler(Object message);
 
 /// The command for invoking the modular compiler.
-class CompileCommand extends Command {
-  final MessageHandler messageHandler;
+class CompileCommand {
+  final MessageHandler _print;
   CompilerOptions _compilerOptions;
+  final ArgParser _argParser = new ArgParser();

[nweiz, 2016/08/12 20:30:57]

Nit: this doesn't need to be type-annotated.

[Jennifer Messerly, 2016/08/12 21:08:01]

true. Although it unfortunately needs the type annotation after removing the
class & having addArguments methods return "void". (see updated version of this
file)

 
   CompileCommand({MessageHandler messageHandler})
-      : this.messageHandler = messageHandler ?? print {
-    argParser.addOption('out', abbr: 'o', help: 'Output file (required)');
-    argParser.addOption('module-root',
-        help: 'Root module directory. '
+      : _print = messageHandler ?? print {
+    _argParser.addOption('out', abbr: 'o', help: 'Output file (required)');
+    _argParser.addOption('module-root',
+        help: 'Root module directory.\n'
             'Generated module paths are relative to this root.');
-    argParser.addOption('library-root',
-        help: 'Root of source files. '
+    _argParser.addOption('library-root',
+        help: 'Root of source files.\n'
             'Generated library names are relative to this root.');
-    argParser.addOption('build-root',
-        help: 'Deprecated in favor of --library-root');
-    CompilerOptions.addArguments(argParser);
-    AnalyzerOptions.addArguments(argParser);
+    _argParser.addOption('build-root',
+        help: 'Deprecated in favor of --library-root', hide: true);
+    CompilerOptions.addArguments(_argParser);
+    AnalyzerOptions.addArguments(_argParser);
   }
 
-  get name => 'compile';
-  get description => 'Compile a set of Dart files into a JavaScript module.';
+  int run(List<String> args) {
+    try {
+      _run(_argParser.parse(args));
+      return 0;
+    } on UsageException catch (error) {
+      // Incorrect usage, input file not found, etc.
+      _print(error);
+      return 64;
+    } on CompileErrorException catch (error) {
+      // Code has error(s) and failed to compile.
+      _print(error);
+      return 1;
+    } catch (error, stackTrace) {
+      // Anything else is likely a compiler bug.
+      //
+      // --unsafe-force-compile is a bit of a grey area, but it's nice not to
+      // crash while compiling
+      // (of course, output code may crash, if it had errors).
+      //
+      _print("");
+      _print("We're sorry, you've found a bug in our compiler.");
+      _print("You can report this bug at:");
+      _print("    https://github.com/dart-lang/dev_compiler/issues");
+      _print("");
+      _print(
+          "Please include the information below in your report, along with");
+      _print(
+          "any other information that may help us track it down. Thanks!");
+      _print("");
+      _print("    dartdevc arguments: " + args.join(' '));
+      _print("    dart --version: ${Platform.version}");
+      _print("");
+      _print("```");
+      _print(error);
+      _print(stackTrace);
+      _print("```");

[nweiz, 2016/08/12 20:30:57]

Make this a multi-line string rather than calling _print over and over. If a
MessageHandler only supports a single line at a time, add a helper method to
split a string and call _print on the results rather than doing it manually.

[Jennifer Messerly, 2016/08/12 21:08:01]

Done. As a general rule I try and not fix-all-the-things when doing a refactor.
But that said I'm happy to fix this case as it's easy enough and a lot nicer
looking.

[nweiz, 2016/08/12 21:16:37]

My philosophy is, if I don't fix incidental stuff as part of other changes, I'll
never find time to fix them at all. :)

+      return 70;
+    }
+  }
 
-  @override
-  void run() {
+  void _run(ArgResults argResults) {
     var compiler =
         new ModuleCompiler(new AnalyzerOptions.fromArguments(argResults));
     _compilerOptions = new CompilerOptions.fromArguments(argResults);
     var outPath = argResults['out'];
 
     if (outPath == null) {
-      usageException('Please include the output file location. For example:\n'
+      _usageException('Please include the output file location. For example:\n'
           '    -o PATH/TO/OUTPUT_FILE.js');
     }
 
     var libraryRoot = argResults['library-root'] as String;
     libraryRoot ??= argResults['build-root'] as String;
     if (libraryRoot != null) {
       libraryRoot = path.absolute(libraryRoot);
     } else {
       libraryRoot = Directory.current.path;
     }
     var moduleRoot = argResults['module-root'] as String;
     String modulePath;
     if (moduleRoot != null) {
       moduleRoot = path.absolute(moduleRoot);
       if (!path.isWithin(moduleRoot, outPath)) {
-        usageException('Output file $outPath must be within the module root '
+        _usageException('Output file $outPath must be within the module root '
             'directory $moduleRoot');
       }
       modulePath =
           path.withoutExtension(path.relative(outPath, from: moduleRoot));
     } else {
       moduleRoot = path.dirname(outPath);
       modulePath = path.basenameWithoutExtension(outPath);
     }
 
     var unit = new BuildUnit(modulePath, libraryRoot, argResults.rest,
         (source) => _moduleForLibrary(moduleRoot, source));
 
     JSModuleFile module = compiler.compile(unit, _compilerOptions);
-    module.errors.forEach(messageHandler);
+    module.errors.forEach(_print);
 
     if (!module.isValid) throw new CompileErrorException();
 
     // Write JS file, as well as source map and summary (if requested).
     new File(outPath).writeAsStringSync(module.code);
     if (module.sourceMap != null) {
       var mapPath = outPath + '.map';
       new File(mapPath)
           .writeAsStringSync(JSON.encode(module.placeSourceMap(mapPath)));
     }
     if (module.summaryBytes != null) {
       var summaryPath = path.withoutExtension(outPath) +
           '.${_compilerOptions.summaryExtension}';
       new File(summaryPath).writeAsBytesSync(module.summaryBytes);
     }
   }
 
   String _moduleForLibrary(String moduleRoot, Source source) {
     if (source is InSummarySource) {
       var summaryPath = source.summaryPath;
       var ext = '.${_compilerOptions.summaryExtension}';
       if (path.isWithin(moduleRoot, summaryPath) && summaryPath.endsWith(ext)) {
         var buildUnitPath =
             summaryPath.substring(0, summaryPath.length - ext.length);
         return path.relative(buildUnitPath, from: moduleRoot);
       }
 
-      throw usageException(
+      _usageException(
           'Imported file ${source.uri} is not within the module root '
           'directory $moduleRoot');
     }
 
-    throw usageException(
+    _usageException(
         'Imported file "${source.uri}" was not found as a summary or source '
         'file. Please pass in either the summary or the source file '
         'for this import.');
+    return null; // unreachable
+  }
+
+  void _usageException(String message) {
+    throw new UsageException(
+        message,
+        'Dart Development Compiler compiles Dart into a JavaScript module.'
+        '\n\n${_argParser.usage}');
   }
 }
 
 /// Thrown when the input source code has errors.
 class CompileErrorException implements Exception {
   toString() => '\nPlease fix all errors before compiling (warnings are okay).';
 }