move extractDefinedVariables from analyzer cli to analyzer

pkg/analyzer/lib/src/command_line/arguments.dart

 // Copyright (c) 2016, 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.src.command_line.arguments;
 
 import 'dart:collection';
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/builder.dart';
@@ skipping 147 matching lines @@
       negatable: false,
       hide: true);
 //  parser.addFlag('enable_type_checks',
 //      help: 'Check types in constant evaluation.',
 //      defaultsTo: false,
 //      negatable: false,
 //      hide: true);
 }
 
 /**
+ * Find arguments of the form -Dkey=value
+ * or argument pairs of the form -Dkey value
+ * and place those key/value pairs into [definedVariables].
+ * Return a list of arguments with the key/value arguments removed.
+ */
+List<String> extractDefinedVariables(

[Brian Wilkerson, 2016/12/14 17:47:35]

This is already being done as part of createContextBuilderOptions. Given that we
want to move everyone to using ContextBuilder, we could just build the options,
and extract the declared variables for now knowing that this gets us closer to
the longer term goal.

[danrubel, 2016/12/14 18:06:56]

That makes sense as a long term goal, but I'd like to take it in smaller steps.
I tried to be more ambitious last week and didn't make any progress. I found
that detangling and normalizing Analyzer CLI and DDC code to be more involved
than I thought. This week I'm taking it in smaller steps and making good
progress. Ok if I check this in as a step towards what you describe?

+    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")) {
+      if (i + 1 < count) {
+        definedVariables[arg.substring(2)] = args[++i];
+      } else {
+        remainingArgs.add(arg);
+      }
+    } else {
+      remainingArgs.add(arg);
+    }
+  }
+  return remainingArgs;
+}
+
+/**
  * Return a list of command-line arguments containing all of the given [args]
  * that are defined by the given [parser]. An argument is considered to be
  * defined by the parser if
  * - it starts with '--' and the rest of the argument (minus any value
  *   introduced by '=') is the name of a known option,
  * - it starts with '-' and the rest of the argument (minus any value
  *   introduced by '=') is the name of a known abbreviation, or
  * - it starts with something other than '--' or '-'.
  *
  * This function allows command-line tools to implement the
@@ skipping 69 matching lines @@
           .replaceAll('\r\n', '\n')
           .replaceAll('\r', '\n')
           .split('\n')
           .where((String line) => line.isNotEmpty));
     } on FileSystemException catch (e) {
       throw new Exception('Failed to read file specified by $lastArg : $e');
     }
   }
   return args;
 }