More fixes for java2dart and status files.

pkg/analyzer_experimental/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 'package:args/args.dart';
 
 import 'dart:io';
 
@@ skipping 68 matching lines @@
       if (!(new Directory(sdkPath)).existsSync()) {
         print('Usage: $_BINARY_NAME: invalid Dart SDK path: $sdkPath');
         exit(15);
       }
     }
     // OK
     return options;
   }
 
   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('package-root', help: 'The path to the package root')
       ..addFlag('machine',
           help: 'Print errors in a format suitable for parsing',
           defaultsTo: false, negatable: false)
       ..addFlag('version', help: 'Print the analyzer version',
           defaultsTo: false, negatable: false)
@@ skipping 94 matching lines @@
   }
 
   /**
    * 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}) {
+    _knownFlags.add(name);
     _parser.addOption(name, abbr: abbr, help: help, allowed: allowed,
         allowedHelp: allowedHelp, defaultsTo: defaultsTo, callback: callback,
         allowMultiple: allowMultiple);
   }
 
 
   /**
    * Generates a string displaying usage information for the defined options.
    *
    * See [ArgParser.getUsage()].
    */
   String getUsage() => _parser.getUsage();
 
   /**
    * Parses [args], a list of command-line arguments, matches them against the
    * flags and options defined by this parser, and returns the result.
    *
    * See [ArgParser].
    */
   ArgResults parse(List<String> args) => _parser.parse(_filterUnknowns(args));
 
   List<String> _filterUnknowns(args) {
 
     // Only filter args if the ignore flag is specified.
-    if (!args.contains('--ignore_unrecognized_flags')) {
+    if (!args.contains('--ignore-unrecognized-flags')) {
       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) {
       var arg = args[i];
       if (arg.startsWith('--') && arg.length > 2) {
         if (!_knownFlags.contains(arg.substring(2))) {
+          print('remove: $arg');
           //"eat" params by advancing to the next flag/option
           i = _getNextFlagIndex(args, i);
         } else {
           filtered.add(arg);
         }
       } else {
         filtered.add(arg);
       }
     }
 
+    print(filtered);
     return filtered;
   }
 
   _getNextFlagIndex(args, i) {
     for ( ; i < args.length; ++i) {
       if (args[i].startsWith('--')) {
         return i;
       }
     }
     return i;
   }
 }