Introduce flags to allow filtering of targets by rule name

This commit introduces two new flags: `--build_rule_filters` &
`--test_rule_filters`. They behave in a very similar manner to
existing filter flags, e.g. tag, timeout, size, lang, etc., and will
allow users to filter out or in targets for building/testing that
use a specific rule.

Author: alexander-scott

src/main/java/com/google/devtools/build/lib/packages/TargetUtils.java

@@ -381,6 +381,29 @@ public static Predicate<Target> tagFilter(List<String> tagFilterList) {
     };
   }
 
+    /**
+   * Returns a predicate to be used for test rule name filtering, i.e., that only accepts tests that match
+   * a required rule name and not an excluded rule name.
+   */
+  public static Predicate<Target> ruleFilter(List<String> ruleFilterList) {
+    Pair<Collection<String>, Collection<String>> ruleLists =
+        TestTargetUtils.sortTagsBySense(ruleFilterList);
+    final Collection<String> requiredRules = ruleLists.first;
+    final Collection<String> excludedRules = ruleLists.second;
+    return input -> {
+      if (requiredRules.isEmpty() && excludedRules.isEmpty()) {
+        return true;
+      }
+
+      if (!(input instanceof Rule)) {
+        return requiredRules.isEmpty();
+      }
+
+      return TestTargetUtils.testMatchesRuleFilters(
+          ((Rule) input).getRuleClass(), requiredRules, excludedRules);
+    };
+  }
+
   /** Return {@link Location} for {@link Target} target, if it should not be null. */
   @Nullable
   public static Location getLocationMaybe(Target target) {

src/main/java/com/google/devtools/build/lib/packages/TestTargetUtils.java

@@ -91,6 +91,18 @@ private static boolean testMatchesFilters(
     return testMatchesFilters(testTags, requiredTags, excludedTags);
   }
 
+  /**
+   * Returns whether a test with a rule name matches a filter (as specified by the set
+   * of its positive and its negative filters).
+   */
+  public static boolean testMatchesRuleFilters(
+      String ruleName,
+      Collection<String> requiredRules,
+      Collection<String> excludedRules) {
+    return (requiredRules.isEmpty() || requiredRules.contains(ruleName)) &&
+            !excludedRules.contains(ruleName);
+  }
+
   /**
    * Filters 'tests' (by mutation) according to the 'tags' attribute, specifically those that
    * match ALL of the tags in tagsAttribute.

src/main/java/com/google/devtools/build/lib/pkgcache/LoadingOptions.java

@@ -128,6 +128,35 @@ public class LoadingOptions extends OptionsBase {
   )
   public List<String> testLangFilterList;
 
+  @Option(
+    name = "build_rule_filters",
+    converter = CommaSeparatedOptionListConverter.class,
+    defaultValue = "",
+    documentationCategory = OptionDocumentationCategory.UNCATEGORIZED,
+    effectTags = {OptionEffectTag.UNKNOWN},
+    help =
+        "Specifies a comma-separated list of rule names. Each rule name can be optionally "
+            + "preceded with '-' to specify excluded rule names. Only those targets will be built that "
+            + "equal the positive rule name or do not equal the negative rule name. This option "
+            + "does not affect the set of tests executed with the 'test' command; those are be "
+            + "governed by the test filtering options, for example '--test_rule_filters'"
+  )
+  public List<String> buildRuleFilterList;
+
+  @Option(
+    name = "test_rule_filters",
+    converter = CommaSeparatedOptionListConverter.class,
+    defaultValue = "",
+    documentationCategory = OptionDocumentationCategory.UNCATEGORIZED,
+    effectTags = {OptionEffectTag.UNKNOWN},
+    help =
+      "Specifies a comma-separated list of rule names. Each rule name can be optionally "
+      + "preceded with '-' to specify excluded rule names. Only those test targets will be "
+      + "found that equal the positive rule name or do not equal the negative rule name."
+      + "This option affects --build_tests_only behavior and the test command."
+  )
+  public List<String> testRuleFilterList;
+
   @Option(
     name = "build_manual_tests",
     defaultValue = "false",

src/main/java/com/google/devtools/build/lib/pkgcache/TestFilter.java

@@ -46,25 +46,29 @@ public static TestFilter forOptions(LoadingOptions options) {
         ImmutableSet.copyOf(options.testSizeFilterSet),
         ImmutableSet.copyOf(options.testTimeoutFilterSet),
         ImmutableList.copyOf(options.testTagFilterList),
-        ImmutableList.copyOf(options.testLangFilterList));
+        ImmutableList.copyOf(options.testLangFilterList),
+        ImmutableList.copyOf(options.testRuleFilterList));
   }
 
   private final ImmutableSet<TestSize> testSizeFilterSet;
   private final ImmutableSet<TestTimeout> testTimeoutFilterSet;
   private final ImmutableList<String> testTagFilterList;
   private final ImmutableList<String> testLangFilterList;
+  private final ImmutableList<String> testRuleFilterList;
   private final Predicate<Target> impl;
 
   @VisibleForSerialization
   TestFilter(
       ImmutableSet<TestSize> testSizeFilterSet,
       ImmutableSet<TestTimeout> testTimeoutFilterSet,
       ImmutableList<String> testTagFilterList,
-      ImmutableList<String> testLangFilterList) {
+      ImmutableList<String> testLangFilterList,
+      ImmutableList<String> testRuleFilterList) {
     this.testSizeFilterSet = testSizeFilterSet;
     this.testTimeoutFilterSet = testTimeoutFilterSet;
     this.testTagFilterList = testTagFilterList;
     this.testLangFilterList = testLangFilterList;
+    this.testRuleFilterList = testRuleFilterList;
     Predicate<Target> testFilter = ALWAYS_TRUE;
     if (!testSizeFilterSet.isEmpty()) {
       testFilter = testFilter.and(testSizeFilter(testSizeFilterSet));
@@ -78,6 +82,9 @@ public static TestFilter forOptions(LoadingOptions options) {
     if (!testLangFilterList.isEmpty()) {
       testFilter = testFilter.and(testLangFilter(testLangFilterList));
     }
+    if (!testRuleFilterList.isEmpty()) {
+      testFilter = testFilter.and(testRuleFilter(testRuleFilterList));
+    }
     impl = testFilter;
   }
 
@@ -89,7 +96,7 @@ public boolean apply(@Nullable Target input) {
   @Override
   public int hashCode() {
     return Objects.hash(testSizeFilterSet, testTimeoutFilterSet, testTagFilterList,
-        testLangFilterList);
+        testLangFilterList, testRuleFilterList);
   }
 
   @Override
@@ -103,7 +110,8 @@ public boolean equals(Object o) {
     return f.testSizeFilterSet.equals(testSizeFilterSet)
         && f.testTimeoutFilterSet.equals(testTimeoutFilterSet)
         && f.testTagFilterList.equals(testTagFilterList)
-        && f.testLangFilterList.equals(testLangFilterList);
+        && f.testLangFilterList.equals(testLangFilterList)
+        && f.testRuleFilterList.equals(testRuleFilterList);
   }
 
   @Override
@@ -113,6 +121,7 @@ public String toString() {
         .add("testTimeoutFilterSet", testTimeoutFilterSet)
         .add("testTagFilterList", testTagFilterList)
         .add("testLangFilterList", testLangFilterList)
+        .add("testRuleFilterList", testRuleFilterList)
         .toString();
   }
 
@@ -159,4 +168,28 @@ private static Predicate<Target> testLangFilter(List<String> langFilterList) {
           && !excludedLangs.contains(ruleLang);
     };
   }
+
+    /**
+   * Returns a predicate to be used for test rule filtering, i.e., that only accepts tests of
+   * the specified rule names.
+   */
+  private static Predicate<Target> testRuleFilter(List<String> ruleFilterList) {
+    final Set<String> requiredRules = new HashSet<>();
+    final Set<String> excludedRules = new HashSet<>();
+
+    for (String ruleFilter : ruleFilterList) {
+      if (ruleFilter.startsWith("-")) {
+        ruleFilter = ruleFilter.substring(1);
+        excludedRules.add(ruleFilter);
+      } else {
+        requiredRules.add(ruleFilter);
+      }
+    }
+
+    return rule -> {
+      String ruleName = rule.getRuleClass();
+      return (requiredRules.isEmpty() || requiredRules.contains(ruleName))
+          && !excludedRules.contains(ruleName);
+    };
+  }
 }

src/main/java/com/google/devtools/build/lib/skyframe/SkyframeExecutor.java

@@ -3002,6 +3002,7 @@ public TargetPatternPhaseValue loadTargetPatternsWithFilters(
             options.buildTestsOnly,
             determineTests,
             ImmutableList.copyOf(options.buildTagFilterList),
+            ImmutableList.copyOf(options.buildRuleFilterList),
             options.buildManualTests,
             options.expandTestSuites,
             TestFilter.forOptions(options));

src/main/java/com/google/devtools/build/lib/skyframe/TargetPatternPhaseFunction.java

@@ -367,8 +367,10 @@ private static ResolvedTargets<Target> mergeAll(
       }
     }
 
-    ResolvedTargets<Target> result =
-        builder.filter(TargetUtils.tagFilter(options.getBuildTargetFilter())).build();
+    builder.filter(TargetUtils.tagFilter(options.getBuildTargetFilter()));
+    builder.filter(TargetUtils.ruleFilter(options.getBuildRuleFilter()));
+
+    ResolvedTargets<Target> result = builder.build();
     if (options.getCompileOneDependency()) {
       EnvironmentBackedRecursivePackageProvider environmentBackedRecursivePackageProvider =
           new EnvironmentBackedRecursivePackageProvider(env);

src/main/java/com/google/devtools/build/lib/skyframe/TargetPatternPhaseValue.java

@@ -155,6 +155,7 @@ public static TargetPatternPhaseKey key(
       boolean buildTestsOnly,
       boolean determineTests,
       ImmutableList<String> buildTargetFilter,
+      ImmutableList<String> buildRuleFilter,
       boolean buildManualTests,
       boolean expandTestSuites,
       @Nullable TestFilter testFilter) {
@@ -165,6 +166,7 @@ public static TargetPatternPhaseKey key(
         buildTestsOnly,
         determineTests,
         buildTargetFilter,
+        buildRuleFilter,
         buildManualTests,
         expandTestSuites,
         testFilter);
@@ -181,7 +183,7 @@ public static TargetPatternPhaseKey key(
   public static SkyKey keyWithoutFilters(
       ImmutableList<String> targetPatterns, PathFragment offset) {
     return new TargetPatternPhaseKey(
-        targetPatterns, offset, false, false, false, ImmutableList.of(), false, false, null);
+        targetPatterns, offset, false, false, false, ImmutableList.of(), ImmutableList.of(), false, false, null);
   }
 
   /** The configuration needed to run the target pattern evaluation phase. */
@@ -194,6 +196,7 @@ static final class TargetPatternPhaseKey implements SkyKey {
     private final boolean buildTestsOnly;
     private final boolean determineTests;
     private final ImmutableList<String> buildTargetFilter;
+    private final ImmutableList<String> buildRuleFilter;
     private final boolean buildManualTests;
     private final boolean expandTestSuites;
     @Nullable private final TestFilter testFilter;
@@ -205,6 +208,7 @@ private TargetPatternPhaseKey(
         boolean buildTestsOnly,
         boolean determineTests,
         ImmutableList<String> buildTargetFilter,
+        ImmutableList<String> buildRuleFilter,
         boolean buildManualTests,
         boolean expandTestSuites,
         @Nullable TestFilter testFilter) {
@@ -214,6 +218,7 @@ private TargetPatternPhaseKey(
       this.buildTestsOnly = buildTestsOnly;
       this.determineTests = determineTests;
       this.buildTargetFilter = Preconditions.checkNotNull(buildTargetFilter);
+      this.buildRuleFilter = Preconditions.checkNotNull(buildRuleFilter);
       this.buildManualTests = buildManualTests;
       this.expandTestSuites = expandTestSuites;
       this.testFilter = testFilter;
@@ -251,6 +256,10 @@ public ImmutableList<String> getBuildTargetFilter() {
       return buildTargetFilter;
     }
 
+    public ImmutableList<String> getBuildRuleFilter() {
+      return buildRuleFilter;
+    }
+
     public boolean getBuildManualTests() {
       return buildManualTests;
     }
@@ -305,6 +314,7 @@ public boolean equals(Object obj) {
           && other.buildTestsOnly == buildTestsOnly
           && other.determineTests == determineTests
           && other.buildTargetFilter.equals(buildTargetFilter)
+          && other.buildRuleFilter.equals(buildRuleFilter)
           && other.buildManualTests == buildManualTests
           && other.expandTestSuites == expandTestSuites
           && Objects.equals(other.testFilter, testFilter);