Add ignore-unrecognized-flags as an option to the command line options of analysis server

pkg/analyzer/lib/options.dart

 // Copyright (c) 2013, 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 options;
 
 import 'dart:io';
 
 import 'package:args/args.dart';
 
@@ skipping 115 matching lines @@
       File versionFile = new File(versionPath);
       return versionFile.readAsStringSync().trim();
     } catch (_) {
       // This happens when the script is not running in the context of an SDK.
       return "<unknown>";
     }
   }
 
   static CommandLineOptions _parse(List<String> args) {
     args = args.expand((String arg) => arg.split('=')).toList();
-    var parser = new _CommandLineParser()
+    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(
             'package-root',
             abbr: 'p',
@@ skipping 54 matching lines @@
             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)
         //
         // Hidden flags.
         //
         ..addFlag(
             'enable-async',
             help: 'Enable support for the proposed async feature',
             defaultsTo: false,
             negatable: false,
             hide: true)
@@ skipping 52 matching lines @@
       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);
+          results,
+          definedVariables,
+          customUrlMappings);
     } on FormatException catch (e) {
       print(e.message);
       _showUsage(parser);
       exit(15);
     }
 
   }
 
   static _showUsage(parser) {
     print('Usage: $_BINARY_NAME [options...] <libraries to analyze...>');
     print(parser.getUsage());
     print('');
     print('For more information, see http://www.dartlang.org/tools/analyzer.');
   }
 }
 
 /**
  * Commandline argument parser.
  *
  * TODO(pquitslund): when the args package supports ignoring unrecognized
  * options/flags, this class can be replaced with a simple [ArgParser] instance.
  */
-class _CommandLineParser {
+class CommandLineParser {
 
   final List<String> _knownFlags;
+  final bool _alwaysIgnoreUnrecognized;
   final ArgParser _parser;
 
   /** Creates a new command line parser */
-  _CommandLineParser()
+  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}) {
     _knownFlags.add(name);
     _parser.addFlag(
         name,
@@ skipping 57 matching lines @@
         definedVariables[arg.substring(2)] = args[++i];
       } else {
         remainingArgs.add(arg);
       }
     }
     return remainingArgs;
   }
 
   List<String> _filterUnknowns(args) {
 
-    // Only filter args if the ignore flag is specified.
-    if (!args.contains('--ignore-unrecognized-flags')) {
+    // Only filter args if the ignore flag is specified, or if
+    // _alwaysIgnoreUnrecognized was set to true
+    if (_alwaysIgnoreUnrecognized ||
+        !args.contains('--ignore-unrecognized-flags')) {

[Brian Wilkerson, 2015/02/19 21:58:21]

This looks wrong. Previously, we would return immediately if we did *not* want
to ignore unrecognized flags (because the flag was not included). Now we return
immediately if the flag was not included or if we explicitly said we wanted to
ignore unrecognized flags.

Suggests that we need some tests for this new behavior.

The logic would be easier to see if the remainder of this method were inside the
'if'.

       return args;
     }
     //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.
     var filtered = <String>[];
     for (var i = 0; i < args.length; ++i) {
@@ skipping 16 matching lines @@
 
   _getNextFlagIndex(args, i) {
     for ( ; i < args.length; ++i) {
       if (args[i].startsWith('--')) {
         return i;
       }
     }
     return i;
   }
 }