Get Target out of TargetParsingCompleteEvent.

Makes it easier to serialize Events.

PiperOrigin-RevId: 197640007

1 files changed, 61 insertions, 23 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/pkgcache/TargetParsingCompleteEvent.java b/src/main/java/com/google/devtools/build/lib/pkgcache/TargetParsingCompleteEvent.java
index e660a5c80e..63abf1be0b 100644
--- a/src/main/java/com/google/devtools/build/lib/pkgcache/TargetParsingCompleteEvent.java
+++ b/src/main/java/com/google/devtools/build/lib/pkgcache/TargetParsingCompleteEvent.java
@@ -14,6 +14,7 @@
 package com.google.devtools.build.lib.pkgcache;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
@@ -23,19 +24,58 @@ import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos;
 import com.google.devtools.build.lib.buildeventstream.BuildEventWithOrderConstraint;
 import com.google.devtools.build.lib.buildeventstream.GenericBuildEvent;
 import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.packages.Rule;
 import com.google.devtools.build.lib.packages.Target;
 import com.google.devtools.build.lib.packages.TargetUtils;
 import java.util.Collection;
 import java.util.List;
+import javax.annotation.Nullable;
 
 /** This event is fired just after target pattern evaluation is completed. */
 public class TargetParsingCompleteEvent implements BuildEventWithOrderConstraint {
+  /** A target-like object that is lighter than a target but has all data needed by callers. */
+  public static class ThinTarget {
+    private final Label label;
+    @Nullable private final String ruleClass;
+    private final String targetKind;
+
+    private ThinTarget(Target target) {
+      this.label = target.getLabel();
+      this.targetKind = target.getTargetKind();
+      this.ruleClass = (target instanceof Rule) ? ((Rule) target).getRuleClass() : null;
+    }
+
+    public boolean isRule() {
+      return ruleClass != null;
+    }
+
+    public String getTargetKind() {
+      return targetKind;
+    }
+
+    public Label getLabel() {
+      return label;
+    }
+
+    /** Gets the rule class of this target. Caller must already know it {@link #isRule}. */
+    public String getRuleClass() {
+      return Preconditions.checkNotNull(ruleClass, label);
+    }
+
+    public boolean isTestSuiteRule() {
+      return isRule() && TargetUtils.isTestSuiteRuleName(getRuleClass());
+    }
+
+    public boolean isNotATestOrTestSuite() {
+      return !isRule() || (!isTestSuiteRule() && !TargetUtils.isTestRuleName(getRuleClass()));
+    }
+  }
 
   private final ImmutableList<String> originalTargetPattern;
-  private final ImmutableSet<Target> targets;
-  private final ImmutableSet<Target> filteredTargets;
-  private final ImmutableSet<Target> testFilteredTargets;
-  private final ImmutableSet<Target> expandedTargets;
+  private final ImmutableSet<ThinTarget> targets;
+  private final ImmutableSet<ThinTarget> filteredTargets;
+  private final ImmutableSet<ThinTarget> testFilteredTargets;
+  private final ImmutableSet<ThinTarget> expandedTargets;
 
   /**
    * Construct the event.
@@ -48,11 +88,11 @@ public class TargetParsingCompleteEvent implements BuildEventWithOrderConstraint
       Collection<Target> testFilteredTargets,
       List<String> originalTargetPattern,
       Collection<Target> expandedTargets) {
-    this.targets = ImmutableSet.copyOf(targets);
-    this.filteredTargets = ImmutableSet.copyOf(filteredTargets);
-    this.testFilteredTargets = ImmutableSet.copyOf(testFilteredTargets);
+    this.targets = asThinTargets(targets);
+    this.filteredTargets = asThinTargets(filteredTargets);
+    this.testFilteredTargets = asThinTargets(testFilteredTargets);
     this.originalTargetPattern = ImmutableList.copyOf(originalTargetPattern);
-    this.expandedTargets = ImmutableSet.copyOf(expandedTargets);
+    this.expandedTargets = asThinTargets(expandedTargets);
   }
 
   @VisibleForTesting
@@ -65,28 +105,22 @@ public class TargetParsingCompleteEvent implements BuildEventWithOrderConstraint
         targets);
   }
 
-  /**
-   * @return the parsed targets, which will subsequently be loaded
-   */
-  public ImmutableSet<Target> getTargets() {
+  /** @return the parsed targets, which will subsequently be loaded */
+  public ImmutableSet<ThinTarget> getTargets() {
     return targets;
   }
 
   public Iterable<Label> getLabels() {
-    return Iterables.transform(targets, Target::getLabel);
+    return Iterables.transform(targets, ThinTarget::getLabel);
   }
 
-  /**
-   * @return the filtered targets (i.e., using -//foo:bar on the command-line)
-   */
-  public ImmutableSet<Target> getFilteredTargets() {
+  /** @return the filtered targets (i.e., using -//foo:bar on the command-line) */
+  public ImmutableSet<ThinTarget> getFilteredTargets() {
     return filteredTargets;
   }
 
-  /**
-   * @return the test-filtered targets, if --build_test_only is in effect
-   */
-  public ImmutableSet<Target> getTestFilteredTargets() {
+  /** @return the test-filtered targets, if --build_test_only is in effect */
+  public ImmutableSet<ThinTarget> getTestFilteredTargets() {
     return testFilteredTargets;
   }
 
@@ -103,10 +137,10 @@ public class TargetParsingCompleteEvent implements BuildEventWithOrderConstraint
   @Override
   public Collection<BuildEventId> getChildrenEvents() {
     ImmutableList.Builder<BuildEventId> childrenBuilder = ImmutableList.builder();
-    for (Target target : expandedTargets) {
+    for (ThinTarget target : expandedTargets) {
       // Test suits won't produce target configuration and  target-complete events, so do not
       // announce here completion as children.
-      if (!TargetUtils.isTestSuiteRule(target)) {
+      if (!target.isTestSuiteRule()) {
         childrenBuilder.add(BuildEventId.targetConfigured(target.getLabel()));
       }
     }
@@ -119,4 +153,8 @@ public class TargetParsingCompleteEvent implements BuildEventWithOrderConstraint
         .setExpanded(BuildEventStreamProtos.PatternExpanded.newBuilder().build())
         .build();
   }
+
+  private static ImmutableSet<ThinTarget> asThinTargets(Collection<Target> targets) {
+    return targets.stream().map(ThinTarget::new).collect(ImmutableSet.toImmutableSet());
+  }
 }