Remove outmoded --url-mapping option.

lib/src/options.dart

 // Copyright (c) 2015, 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 analyzer_cli.src.options;
 
 import 'dart:io';
 
 import 'package:args/args.dart';
 import 'package:cli_util/cli_util.dart' show getSdkDir;
 
 const _binaryName = 'dartanalyzer';
 
 /// Print the given message and exit with the given [exitCode]
 void printAndFail(String message, {int exitCode: 15}) {
   print(message);
   exit(exitCode);
 }
 
 /// Analyzer commandline configuration options.
 class CommandLineOptions {
-
   /// The path to an analysis options file
   final String analysisOptionsFile;
 
   /// The path to the dart SDK
   String dartSdkPath;
 
   /// A table mapping the names of defined variables to their values.
   final Map<String, String> definedVariables;
 
   /// Whether to report hints
@@ skipping 42 matching lines @@
 
   /// Whether to show SDK warnings
   final bool showSdkWarnings;
 
   /// The source files to analyze
   final List<String> sourceFiles;
 
   /// Whether to treat warnings as fatal
   final bool warningsAreFatal;
 
-  /// A table mapping library URIs to the file system path where the library
-  /// source is located.
-  final Map<String, String> customUrlMappings;
-
   /// Whether to use package:dev_compiler for strong static checking.
   final bool strongMode;
 
   /// Whether to emit hints from [strongMode] analysis.
   final bool strongHints;
 
   /// Initialize options from the given parsed [args].
-  CommandLineOptions._fromArgs(ArgResults args,
-      Map<String, String> definedVariables,
-      Map<String, String> customUrlMappings)
+  CommandLineOptions._fromArgs(
+      ArgResults args, Map<String, String> definedVariables)
       : dartSdkPath = args['dart-sdk'],
         this.definedVariables = definedVariables,
         analysisOptionsFile = args['options'],
         disableHints = args['no-hints'],
         displayVersion = args['version'],
         enableNullAwareOperators = args['enable-null-aware-operators'],
         enableStrictCallChecks = args['enable-strict-call-checks'],
         enableSuperMixins = args['supermixin'],
         enableTypeChecks = args['enable_type_checks'],
         ignoreUnrecognizedFlags = args['ignore-unrecognized-flags'],
         lints = args['lints'],
         log = args['log'],
         machineFormat = args['machine'] || args['format'] == 'machine',
         packageConfigPath = args['packages'],
         packageRootPath = args['package-root'],
         shouldBatch = args['batch'],
-        showPackageWarnings = args['show-package-warnings'] ||
-            args['package-warnings'],
+        showPackageWarnings =
+            args['show-package-warnings'] || args['package-warnings'],
         showSdkWarnings = args['show-sdk-warnings'] || args['warnings'],
         sourceFiles = args.rest,
         warningsAreFatal = args['fatal-warnings'],
-        this.customUrlMappings = customUrlMappings,
         strongMode = args['strong'],
         strongHints = args['strong-hints'];
 
   /// Parse [args] into [CommandLineOptions] describing the specified
   /// analyzer options. In case of a format error, calls [printAndFail], which
   /// by default prints an error message and exits.
   static CommandLineOptions parse(List<String> args,
       [printAndFail = printAndFail]) {
     CommandLineOptions options = _parse(args);
     // Check SDK.
@@ skipping 51 matching lines @@
   static CommandLineOptions _parse(List<String> args) {
     args = args.expand((String arg) => arg.split('=')).toList();
     var parser = new CommandLineParser()
       ..addFlag('batch',
           abbr: 'b',
           help: 'Run in batch mode.',
           defaultsTo: false,
           negatable: false)
       ..addOption('dart-sdk', help: 'The path to the Dart SDK.')
       ..addOption('packages',
-          help: 'Path to the package resolution configuration file, which supplies a mapping of package names to paths.  This option cannot be used with --package-root.')
+          help:
+              'Path to the package resolution configuration file, which supplies a mapping of package names to paths.  This option cannot be used with --package-root.')
       ..addOption('package-root',
           abbr: 'p',
-          help: 'Path to a package root directory (deprecated). This option cannot be used with --packages.')
+          help:
+              'Path to a package root directory (deprecated). This option cannot be used with --packages.')
       ..addOption('options', help: 'Path to an analysis options file.')
       ..addOption('format',
           help: 'Specifies the format in which errors are displayed.')
       ..addFlag('machine',
           help: 'Print errors in a format suitable for parsing (deprecated).',
           defaultsTo: false,
           negatable: false)
       ..addFlag('version',
           help: 'Print the analyzer version.',
           defaultsTo: false,
@@ skipping 28 matching lines @@
           help: 'Show warnings from SDK imports (deprecated).',
           defaultsTo: false,
           negatable: false)
       ..addFlag('help',
           abbr: 'h',
           help: 'Display this help message.',
           defaultsTo: false,
           negatable: false)
       ..addOption('url-mapping',
           help: '--url-mapping=libraryUri,/path/to/library.dart directs the '
-          'analyzer to use "library.dart" as the source for an import ' 'of "libraryUri".',
+              'analyzer to use "library.dart" as the source for an import '
+              'of "libraryUri".',
           allowMultiple: true,
           splitCommas: false)
       //
       // Hidden flags.
       //
       ..addFlag('enable-async',
           help: 'Enable support for the proposed async feature.',
           defaultsTo: false,
           negatable: false,
           hide: true)
@@ skipping 52 matching lines @@
         }
       } else if (results['version']) {
         print('$_binaryName version ${_getVersion()}');
         exit(0);
       } else {
         if (results.rest.isEmpty) {
           _showUsage(parser);
           exit(15);
         }
       }
-      Map<String, String> customUrlMappings = <String, String>{};
-      for (String mapping in results['url-mapping']) {
-        List<String> splitMapping = mapping.split(',');
-        if (splitMapping.length != 2) {
-          _showUsage(parser);
-          exit(15);
-        }
-        customUrlMappings[splitMapping[0]] = splitMapping[1];
-      }
-      return new CommandLineOptions._fromArgs(
-          results, definedVariables, customUrlMappings);
+      return new CommandLineOptions._fromArgs(results, definedVariables);
     } on FormatException catch (e) {
       print(e.message);
       _showUsage(parser);
       exit(15);
     }
   }
 
   static _showUsage(parser) {
     print('Usage: $_binaryName [options...] <libraries to analyze...>');
     print(parser.getUsage());
@@ skipping 15 matching lines @@
   /// Creates a new command line parser.
   CommandLineParser({bool alwaysIgnoreUnrecognized: false})
       : _knownFlags = <String>[],
         _alwaysIgnoreUnrecognized = alwaysIgnoreUnrecognized,
         _parser = new ArgParser(allowTrailingOptions: true);
 
   ArgParser get parser => _parser;
 
   /// Defines a flag.
   /// See [ArgParser.addFlag()].
-  void addFlag(String name, {String abbr, String help, bool defaultsTo: false,
-      bool negatable: true, void callback(bool value), bool hide: false}) {
+  void addFlag(String name,
+      {String abbr,
+      String help,
+      bool defaultsTo: false,
+      bool negatable: true,
+      void callback(bool value),
+      bool hide: false}) {
     _knownFlags.add(name);
     _parser.addFlag(name,
         abbr: abbr,
         help: help,
         defaultsTo: defaultsTo,
         negatable: negatable,
         callback: callback,
         hide: hide);
   }
 
   /// Defines a value-taking option.
   /// See [ArgParser.addOption()].
-  void addOption(String name, {String abbr, String help, List<String> allowed,
-      Map<String, String> allowedHelp, String defaultsTo, void callback(value),
-      bool allowMultiple: false, bool splitCommas}) {
+  void addOption(String name,
+      {String abbr,
+      String help,
+      List<String> allowed,
+      Map<String, String> allowedHelp,
+      String defaultsTo,
+      void callback(value),
+      bool allowMultiple: false,
+      bool splitCommas}) {
     _knownFlags.add(name);
     _parser.addOption(name,
         abbr: abbr,
         help: help,
         allowed: allowed,
         allowedHelp: allowedHelp,
         defaultsTo: defaultsTo,
         callback: callback,
         allowMultiple: allowMultiple,
         splitCommas: splitCommas);
   }
 
   /// Generates a string displaying usage information for the defined options.
   /// See [ArgParser.usage].
   String getUsage() => _parser.usage;
 
   /// Parses [args], a list of command-line arguments, matches them against the
   /// flags and options defined by this parser, and returns the result. The
   /// values of any defined variables are captured in the given map.
   /// See [ArgParser].
-  ArgResults parse(
-      List<String> args, Map<String, String> definedVariables) => _parser
-      .parse(_filterUnknowns(parseDefinedVariables(args, definedVariables)));
+  ArgResults parse(List<String> args, Map<String, String> definedVariables) =>
+      _parser.parse(
+          _filterUnknowns(parseDefinedVariables(args, definedVariables)));
 
   List<String> parseDefinedVariables(
       List<String> args, Map<String, String> definedVariables) {
     int count = args.length;
     List<String> remainingArgs = <String>[];
     for (int i = 0; i < count; i++) {
       String arg = args[i];
       if (arg == '--') {
         while (i < count) {
           remainingArgs.add(args[i++]);
         }
       } else if (arg.startsWith("-D")) {
         definedVariables[arg.substring(2)] = args[++i];
       } else {
         remainingArgs.add(arg);
       }
     }
     return remainingArgs;
   }
 
   List<String> _filterUnknowns(List<String> args) {
-
     // Only filter args if the ignore flag is specified, or if
     // _alwaysIgnoreUnrecognized was set to true.
     if (_alwaysIgnoreUnrecognized ||
         args.contains('--ignore-unrecognized-flags')) {
-
       //TODO(pquitslund): replace w/ the following once library skew issues are
       // sorted out
       //return args.where((arg) => !arg.startsWith('--') ||
       //  _knownFlags.contains(arg.substring(2)));
 
       // Filter all unrecognized flags and options.
       List<String> filtered = <String>[];
       for (int i = 0; i < args.length; ++i) {
         String arg = args[i];
         if (arg.startsWith('--') && arg.length > 2) {
@@ skipping 23 matching lines @@
 
   int _getNextFlagIndex(args, i) {
     for (; i < args.length; ++i) {
       if (args[i].startsWith('--')) {
         return i;
       }
     }
     return i;
   }
 }