Use boolean selector syntax for tags.

lib/src/runner/configuration/args.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.
 
 import 'dart:io';
 
 import 'package:args/args.dart';
+import 'package:boolean_selector/boolean_selector.dart';
 
 import '../../backend/test_platform.dart';
 import '../../frontend/timeout.dart';
-import '../../utils.dart';
 import '../configuration.dart';
 import 'values.dart';
 
 /// The parser used to parse the command-line arguments.
 final ArgParser _parser = (() {
   var parser = new ArgParser(allowTrailingOptions: true);
 
   var allPlatforms = TestPlatform.all.toList();
   if (!Platform.isMacOS) allPlatforms.remove(TestPlatform.safari);
   if (!Platform.isWindows) allPlatforms.remove(TestPlatform.internetExplorer);
@@ skipping 13 matching lines @@
       abbr: 'n',
       help: 'A substring of the name of the test to run.\n'
           'Regular expression syntax is supported.');
   parser.addOption("plain-name",
       abbr: 'N',
       help: 'A plain-text substring of the name of the test to run.');
   // TODO(nweiz): Support the full platform-selector syntax for choosing which
   // tags to run. In the shorter term, disallow non-"identifier" tags.
   parser.addOption("tags",
       abbr: 't',
-      help: 'Run only tests with all of the specified tags.',
+      help: 'Run only tests with all of the specified tags.\n'
+          'Supports boolean selector syntax.',
       allowMultiple: true);
   parser.addOption("tag", hide: true, allowMultiple: true);
   parser.addOption("exclude-tags",
       abbr: 'x',
-      help: "Don't run tests with any of the specified tags.",
+      help: "Don't run tests with any of the specified tags.\n"
+          "Supports boolean selector syntax.",
       allowMultiple: true);
   parser.addOption("exclude-tag", hide: true, allowMultiple: true);
 
   parser.addSeparator("======== Running Tests");
   parser.addOption("platform",
       abbr: 'p',
       help: 'The platform(s) on which to run the tests.',
       defaultsTo: 'vm',
       allowed: allPlatforms.map((platform) => platform.identifier).toList(),
       allowMultiple: true);
@@ skipping 50 matching lines @@
       throw new FormatException(
           "--name and --plain-name may not both be passed.");
     }
 
     pattern = _wrapFormatException(
         options, 'name', (value) => new RegExp(value));
   } else if (options['plain-name'] != null) {
     pattern = options['plain-name'];
   }
 
-  var tags = new Set();
-  tags.addAll(options['tags'] ?? []);
-  tags.addAll(options['tag'] ?? []);
+  var includeTagSet = new Set.from(options['tags'] ?? [])
+    ..addAll(options['tag'] ?? []);
 
-  var excludeTags = new Set();
-  excludeTags.addAll(options['exclude-tags'] ?? []);
-  excludeTags.addAll(options['exclude-tag'] ?? []);
+  var includeTags = includeTagSet.fold(BooleanSelector.all, (selector, tag) {
+    var tagSelector = new BooleanSelector.parse(tag);
+    return selector.intersection(tagSelector);
+  });
 
-  var tagIntersection = tags.intersection(excludeTags);
-  if (tagIntersection.isNotEmpty) {
-    throw new FormatException(
-        'The ${pluralize('tag', tagIntersection.length)} '
-        '${toSentence(tagIntersection)} '
-        '${pluralize('was', tagIntersection.length, plural: 'were')} '
-        'both included and excluded.');
-  }
+  var excludeTagSet = new Set.from(options['exclude-tags'] ?? [])
+    ..addAll(options['exclude-tag'] ?? []);
+
+  var excludeTags = excludeTagSet.fold(BooleanSelector.none, (selector, tag) {
+    var tagSelector = new BooleanSelector.parse(tag);
+    return selector.union(tagSelector);
+  });
 
   // If the user hasn't explicitly chosen a value, we want to pass null values
   // to [new Configuration] so that it considers those fields unset when merging
   // with configuration from the config file.
   ifParsed(name) => options.wasParsed(name) ? options[name] : null;
 
   return new Configuration(
       help: ifParsed('help'),
       version: ifParsed('version'),
       verboseTrace: ifParsed('verbose-trace'),
       jsTrace: ifParsed('js-trace'),
       pauseAfterLoad: ifParsed('pause-after-load'),
       color: ifParsed('color'),
       packageRoot: ifParsed('package-root'),
       reporter: ifParsed('reporter'),
       pubServePort: _wrapFormatException(options, 'pub-serve', int.parse),
       concurrency: _wrapFormatException(options, 'concurrency', int.parse),
       timeout: _wrapFormatException(options, 'timeout',
           (value) => new Timeout.parse(value)),
       pattern: pattern,
       platforms: ifParsed('platform')?.map(TestPlatform.find),
       paths: options.rest.isEmpty ? null : options.rest,
-      includeTags: tags,
+      includeTags: includeTags,
       excludeTags: excludeTags);
 }
 
 /// Runs [parse] on the value of the option [name], and wraps any
 /// [FormatException] it throws with additional information.
 _wrapFormatException(ArgResults options, String name, parse(value)) {
   if (!options.wasParsed(name)) return null;
 
   var value = options[name];
   if (value == null) return null;
 
   try {
     return parse(value);
   } on FormatException catch (error) {
     throw new FormatException('Couldn\'t parse --$name "${options[name]}": '
         '${error.message}');
   }
 }