Deprecate all diagnostics methods that use strings.

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 'errors.dart' show inputError, internalError;
+import 'deprecated_problems.dart'
+    show deprecated_inputError, deprecated_internalProblem;
 
-argumentError(String usage, String message) {
+deprecated_argumentError(String usage, String message) {
   if (usage != null) print(usage);
-  inputError(null, null, message);
+  deprecated_inputError(null, null, message);
 }
 
 class ParsedArguments {
   final Map<String, dynamic> options = <String, dynamic>{};
   final List<String> arguments = <String>[];
 
   toString() => "ParsedArguments($options, $arguments)";
 }
 
 class CommandLine {
@@ skipping 59 matching lines @@
       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 argumentError(usage, "Expected value after '$argument'.");
+            return deprecated_argumentError(
+                usage, "Expected value after '$argument'.");
           }
           value = iterator.current;
         } else {
           index = argument.indexOf("=");
           if (index != -1) {
             value = argument.substring(index + 1);
             argument = argument.substring(0, index);
             valueSpecification = specification[argument];
           }
         }
         if (valueSpecification == null) {
           if (value != null) {
-            return argumentError(
+            return deprecated_argumentError(
                 usage, "Argument '$argument' doesn't take a value: '$value'.");
           }
           result.options[argument] = true;
         } else {
           if (valueSpecification is! String && valueSpecification is! Type) {
-            return argumentError(
+            return deprecated_argumentError(
                 usage,
                 "Unrecognized type of value "
                 "specification: ${valueSpecification.runtimeType}.");
           }
           switch ("$valueSpecification") {
             case ",":
               result.options
                   .putIfAbsent(argument, () => <String>[])
                   .addAll(value.split(","));
               break;
 
             case "int":
             case "bool":
             case "String":
             case "Uri":
               if (result.options.containsKey(argument)) {
-                return argumentError(
+                return deprecated_argumentError(
                     usage,
                     "Multiple values for '$argument': "
                     "'${result.options[argument]}' and '$value'.");
               }
               var parsedValue;
               if (valueSpecification == int) {
                 parsedValue = int.parse(value, onError: (_) {
-                  return argumentError(
+                  return deprecated_argumentError(
                       usage, "Value for '$argument', '$value', isn't an int.");
                 });
               } else if (valueSpecification == bool) {
                 if (value == "true" || value == "yes") {
                   parsedValue = true;
                 } else if (value == "false" || value == "no") {
                   parsedValue = false;
                 } else {
-                  return argumentError(
+                  return deprecated_argumentError(
                       usage,
                       "Value for '$argument' is '$value', "
                       "but expected one of: 'true', 'false', 'yes', or 'no'.");
                 }
               } else if (valueSpecification == Uri) {
                 parsedValue = Uri.base.resolve(value);
               } else if (valueSpecification == String) {
                 parsedValue = value;
               } else if (valueSpecification is String) {
-                return argumentError(
+                return deprecated_argumentError(
                     usage,
                     "Unrecognized value specification: "
                     "'$valueSpecification', try using a type literal instead.");
               } else {
                 // All possible cases should have been handled above.
-                return internalError("assertion failure");
+                return deprecated_internalProblem("assertion failure");
               }
               result.options[argument] = parsedValue;
               break;
 
             default:
-              return argumentError(usage,
+              return deprecated_argumentError(usage,
                   "Unrecognized value specification: '$valueSpecification'.");
           }
         }
       } else if (argument == "/?" || argument == "/h") {
         result.options[argument] = true;
       } else {
         result.arguments.add(argument);
       }
     }
     result.arguments.addAll(nonOptions);
     return result;
   }
 }