anchor.diff:      }
       while (iterator.moveNext()) {
         String argument = iterator.current;
  -      if (argument.startsWith("-")) {
  +      if (argument.startsWith("-") || argument == "/?" || argument == "/h") {
  +        index = argument.indexOf("=");
  +        String value;
  +        if (index != -1) {
  +          value = argument.substring(index + 1);
  +          argument = argument.substring(0, index);
  +        }
           var valueSpecification = specification[argument];
  -        String value;
  -        if (valueSpecification != null) {
  +        if (valueSpecification == null) {
  +          throw new CommandLineProblem.deprecated(
  +              "Unknown option '$argument'.");
  +        }
  +        String canonicalArgument = argument;
  +        if (valueSpecification is String && valueSpecification != ",") {
  +          canonicalArgument = valueSpecification;
  +          valueSpecification = specification[valueSpecification];
  +        }
  +        if (valueSpecification == true || valueSpecification == false) {
  +          valueSpecification = bool;
  +        }
  +        if (valueSpecification is! String && valueSpecification is! Type) {
  +          throw new CommandLineProblem.deprecated("Unrecognized type of value "
  +              "specification: ${valueSpecification.runtimeType}.");
  +        }
  +        final bool requiresValue = valueSpecification != bool;
  +        if (requiresValue && value == null) {
             if (!iterator.moveNext()) {
               throw new CommandLineProblem(
                   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];
  -          }
  -        }
  -        if (valueSpecification == null) {
  -          if (value != null) {
  -            throw new CommandLineProblem.deprecated(
  -                "Option '$argument' doesn't take a value: '$value'.");
  -          }
  -          result.options[argument] = true;
  -        } else {
  -          if (valueSpecification is! String && valueSpecification is! Type) {
  +        }
  +        switch ("$valueSpecification") {
  +          case ",":
  +            result.options
  +                .putIfAbsent(argument, () => <String>[])
  +                .addAll(value.split(","));
  +            break;
  +
  +          case "int":
  +          case "bool":
  +          case "String":
  +          case "Uri":
  +            if (result.options.containsKey(canonicalArgument)) {
  +              return throw new CommandLineProblem.deprecated(
  +                  "Multiple values for '$argument': "
  +                  "'${result.options[canonicalArgument]}' and '$value'.");
  +            }
  +            var parsedValue;
  +            if (valueSpecification == int) {
  +              parsedValue = int.parse(value, onError: (_) {
  +                return throw new CommandLineProblem.deprecated(
  +                    "Value for '$argument', '$value', isn't an int.");
  +              });
  +            } else if (valueSpecification == bool) {
  +              if (value == null || value == "true" || value == "yes") {
  +                parsedValue = true;
  +              } else if (value == "false" || value == "no") {
  +                parsedValue = false;
  +              } else {
  +                return throw new CommandLineProblem.deprecated(
  +                    "Value for '$argument' is '$value', "
  +                    "but expected one of: 'true', 'false', 'yes', or 'no'.");
  +              }
  +            } else if (valueSpecification == Uri) {
  +              parsedValue = Uri.base.resolveUri(new Uri.file(value));
  +            } else if (valueSpecification == String) {
  +              parsedValue = value;
  +            } else if (valueSpecification is String) {
  +              return throw new CommandLineProblem.deprecated(
  +                  "Unrecognized value specification: "
  +                  "'$valueSpecification', try using a type literal instead.");
  +            } else {
  +              // All possible cases should have been handled above.
  +              return unhandled("${valueSpecification.runtimeType}",
  +                  "CommandLine.parse", -1, null);
  +            }
  +            result.options[canonicalArgument] = parsedValue;
  +            break;
  +
  +          default:
               return throw new CommandLineProblem.deprecated(
  -                "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 throw new CommandLineProblem.deprecated(
  -                    "Multiple values for '$argument': "
  -                    "'${result.options[argument]}' and '$value'.");
  -              }
  -              var parsedValue;
  -              if (valueSpecification == int) {
  -                parsedValue = int.parse(value, onError: (_) {
  -                  return throw new CommandLineProblem.deprecated(
  -                      "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 throw new CommandLineProblem.deprecated(
  -                      "Value for '$argument' is '$value', "
  -                      "but expected one of: 'true', 'false', 'yes', or 'no'.");
  -                }
  -              } else if (valueSpecification == Uri) {
  -                parsedValue = Uri.base.resolveUri(new Uri.file(value));
  -              } else if (valueSpecification == String) {
  -                parsedValue = value;
  -              } else if (valueSpecification is String) {
  -                return throw new CommandLineProblem.deprecated(
  -                    "Unrecognized value specification: "
  -                    "'$valueSpecification', try using a type literal instead.");
  -              } else {
  -                // All possible cases should have been handled above.
  -                return unhandled("${valueSpecification.runtimeType}",
  -                    "CommandLine.parse", -1, null);
  -              }
  -              result.options[argument] = parsedValue;
  -              break;
  -
  -            default:
  -              return throw new CommandLineProblem.deprecated(
  -                  "Unrecognized value specification: '$valueSpecification'.");
  -          }
  -        }
  -      } else if (argument == "/?" || argument == "/h") {
  -        result.options[argument] = true;
  +                "Unrecognized value specification: '$valueSpecification'.");
  +        }
         } else {
           result.arguments.add(argument);
         }
       }
  +    specification.forEach((String key, value) {
  +      if (value == bool) {
  +        result.options[key] ??= false;
  +      } else if (value is bool) {
  +        result.options[key] ??= value;
  +      }
  +    });
       result.arguments.addAll(nonOptions);
       return result;
     }
   }
   
  +// Before adding new options here, you must:
  +//  * Document the option.
  +//  * Get an explicit approval from the front-end team.
   const Map<String, dynamic> optionSpecification = const <String, dynamic>{
     "--compile-sdk": Uri,
  +  "--dump-ir": false,
  +  "--exclude-source": false,
     "--fatal": ",",
  +  "--help": false,
  +  "--libraries-json": Uri,
     "--output": Uri,
  -  "-o": Uri,
     "--packages": Uri,
     "--platform": Uri,
  -  "--libraries-json": Uri,
  +  "--sdk": Uri,
  +  "--strong": "--strong-mode",
  +  "--strong-mode": false,
  +  "--sync-async": false,
     "--target": String,
  -  "-t": String,
  +  "--verbose": false,
  +  "--verify": false,
  +  "-h": "--help",
  +  "-o": "--output",
  +  "-t": "--target",
  +  "-v": "--verbose",
  +  "/?": "--help",
  +  "/h": "--help",
   };
   
   ProcessedOptions analyzeCommandLine(
  
positive.code:   ///
    /// An /argument/ is something that isn't an option, for example, a file name.
    ///
    /// The specification is a map of options to one of the type literals `Uri`,
    /// `int`, `bool`, or `String`, or a comma (`","`) that represents option
    /// values of type [Uri], [int], [bool], [String], or a comma-separated list
    /// of [String], respectively.
    ///
    /// If [arguments] contains `"--"`, anything before is parsed as options, and
    /// arguments; anything following is treated as arguments (even if starting
    /// 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) {
      specification ??= const <String, dynamic>{};
  
negative.code:         "Valid targets are:\n  ${targets.keys.join("\n  ")}");
    }
  
    final bool verify = options["--verify"];
  
    final bool dumpIr = options["--dump-ir"];
  
    final bool excludeSource = options["--exclude-source"];
  
    final Uri packages = options["--packages"];
  
  