Parse defined variables in command-line analyzer

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';
 
 const _BINARY_NAME = 'dartanalyzer';
 
 /**
  * Analyzer commandline configuration options.
  */
 class CommandLineOptions {
 
   /** Batch mode (for unit testing) */
   final bool shouldBatch;
 
   /** Whether to use machine format for error display */
   final bool machineFormat;
 
   /** Whether to display version information */
   final bool displayVersion;
 
+  /** A table mapping the names of defined variables to their values. */
+  final Map<String, String> definedVariables;
+
   /** Whether to report hints */
   final bool disableHints;
 
   /** Whether to ignore unrecognized flags */
   final bool ignoreUnrecognizedFlags;
 
   /** Whether to show performance statistics */
   final bool perf;
 
   /** Whether to show package: warnings */
@@ skipping 16 matching lines @@
 
   /** The source files to analyze */
   final List<String> sourceFiles;
 
   /** Whether to log additional analysis messages and exceptions */
   final bool log;
 
   /**
    * Initialize options from the given parsed [args].
    */
-  CommandLineOptions._fromArgs(ArgResults args)
+  CommandLineOptions._fromArgs(ArgResults args, Map<String, String> definedVariables)
     : shouldBatch = args['batch'],
       machineFormat = args['machine'] || args['format'] == 'machine',
       displayVersion = args['version'],
       disableHints = args['no-hints'],
       ignoreUnrecognizedFlags = args['ignore-unrecognized-flags'],
       perf = args['perf'],
       showPackageWarnings = args['show-package-warnings'] || args['package-warnings'],
       showSdkWarnings = args['show-sdk-warnings'] || args['warnings'],
       warmPerf = args['warm-perf'],
       warningsAreFatal = args['fatal-warnings'],
       dartSdkPath = args['dart-sdk'],
       packageRootPath = args['package-root'],
       log = args['log'],
-      sourceFiles = args.rest;
+      sourceFiles = args.rest,
+      this.definedVariables = definedVariables;
 
   /**
    * Parse [args] into [CommandLineOptions] describing the specified
    * analyzer options. In case of a format error, prints error and exists.
    */
   static CommandLineOptions parse(List<String> args) {
     CommandLineOptions options = _parse(args);
     // check SDK
     {
       var sdkPath = options.dartSdkPath;
@@ skipping 51 matching lines @@
       ..addFlag('show-sdk-warnings', help: 'Show warnings from SDK imports (deprecated)',
           defaultsTo: false, negatable: false)
       ..addFlag('help', abbr: 'h', help: 'Display this help message',
           defaultsTo: false, negatable: false)
       ..addFlag('log', help: 'Log additional messages and exceptions',
         defaultsTo: false, negatable: false, hide: true);
 
     try {
       // TODO(scheglov) https://code.google.com/p/dart/issues/detail?id=11061
       args = args.map((String arg) => arg == '-batch' ? '--batch' : arg).toList();
-      var results = parser.parse(args);
+      Map<String, String> definedVariables = <String, String>{};

[pquitslund, 2014/05/22 16:22:40]

I think we want to lose the type annotation for consistency's sake...

+      var results = parser.parse(args, definedVariables);
       // help requests
       if (results['help']) {
         _showUsage(parser);
         exit(0);
       }
       // batch mode and input files
       if (results['batch']) {
         if (results.rest.isNotEmpty) {
           print('No source files expected in the batch mode.');
           _showUsage(parser);
           exit(15);
         }
       } else if (results['version']) {
         print('$_BINARY_NAME version ${_getVersion()}');
         exit(0);
       } else {
         if (results.rest.isEmpty) {
           _showUsage(parser);
           exit(15);
         }
       }
-      return new CommandLineOptions._fromArgs(results);
+      return new CommandLineOptions._fromArgs(results, definedVariables);
     } on FormatException catch (e) {
       print(e.message);
       _showUsage(parser);
       exit(15);
     }
 
   }
 
   static _showUsage(parser) {
     print('Usage: $_BINARY_NAME [options...] <libraries to analyze...>');
@@ skipping 60 matching lines @@
 
   /**
    * 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.
+   * 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) => _parser.parse(_filterUnknowns(args));
+  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) {

[pquitslund, 2014/05/22 16:22:40]

This whole method should probably be cleansed of type annotations.

+    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(args) {
 
     // Only filter args if the ignore flag is specified.
     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('--') ||
@@ skipping 21 matching lines @@
 
   _getNextFlagIndex(args, i) {
     for ( ; i < args.length; ++i) {
       if (args[i].startsWith('--')) {
         return i;
       }
     }
     return i;
   }
 }