Use FastaMessage instead of String. Part 1.

pkg/front_end/lib/src/fasta/command_line.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.
 
 library fasta.command_line;
 
+import 'fasta_codes.dart' show Message, templateFastaCLIArgumentRequired;
+
 import 'deprecated_problems.dart'
     show deprecated_inputError, deprecated_internalProblem;
 
-deprecated_argumentError(String usage, String message) {
-  if (usage != null) print(usage);
+deprecated_argumentError(Message usage, String message) {
+  if (usage != null) print(usage.message);
   deprecated_inputError(null, null, message);
 }
 
+argumentError(Message usage, Message message) {
+  if (usage != null) print(usage.message);
+  deprecated_inputError(null, null, message.message);
+}
+
 class ParsedArguments {
   final Map<String, dynamic> options = <String, dynamic>{};
   final List<String> arguments = <String>[];
 
   toString() => "ParsedArguments($options, $arguments)";
 }
 
 class CommandLine {
   final Map<String, dynamic> options;
 
   final List<String> arguments;
 
-  final String usage;
+  final Message usage;
 
   CommandLine.parsed(ParsedArguments p, this.usage)
       : this.options = p.options,
         this.arguments = p.arguments {
     validate();
     if (verbose) {
       print(p);
     }
   }
 
   CommandLine(List<String> arguments,
-      {Map<String, dynamic> specification, String usage})
+      {Map<String, dynamic> specification, Message usage})
       : this.parsed(parse(arguments, specification, usage), usage);
 
   bool get verbose {
     return options.containsKey("-v") || options.containsKey("--verbose");
   }
 
   /// Override to validate arguments and options.
   void validate() {}
 
   /// Parses a list of command-line [arguments] into options and arguments.
@@ skipping 15 matching lines @@
   /// with, for example, a `-`).
   ///
   /// Anything that looks like an option is assumed to be a `bool` option set
   /// to true, unless it's mentioned in [specification] in which case the
   /// option requires a value, either on the form `--option value` or
   /// `--option=value`.
   ///
   /// This method performs only a limited amount of validation, but if an error
   /// occurs, it will print [usage] along with a specific error message.
   static ParsedArguments parse(List<String> arguments,
-      Map<String, dynamic> specification, String usage) {
+      Map<String, dynamic> specification, Message usage) {
     specification ??= const <String, dynamic>{};
     ParsedArguments result = new ParsedArguments();
     int index = arguments.indexOf("--");
     Iterable<String> nonOptions = const <String>[];
     Iterator<String> iterator = arguments.iterator;
     if (index != -1) {
       nonOptions = arguments.skip(index + 1);
       iterator = arguments.take(index).iterator;
     }
     while (iterator.moveNext()) {
       String argument = iterator.current;
       if (argument.startsWith("-")) {
         var valueSpecification = specification[argument];
         String value;
         if (valueSpecification != null) {
           if (!iterator.moveNext()) {
-            return deprecated_argumentError(
-                usage, "Expected value after '$argument'.");
+            return argumentError(usage,
+                templateFastaCLIArgumentRequired.withArguments(argument));
           }
           value = iterator.current;
         } else {
           index = argument.indexOf("=");
           if (index != -1) {
             value = argument.substring(index + 1);
             argument = argument.substring(0, index);
             valueSpecification = specification[argument];
           }
         }
@@ skipping 68 matching lines @@
       } else if (argument == "/?" || argument == "/h") {
         result.options[argument] = true;
       } else {
         result.arguments.add(argument);
       }
     }
     result.arguments.addAll(nonOptions);
     return result;
   }
 }