Move target pattern parsing to key construction time

So that a subsequent commit can take advantage of semantic information
known only after target patterns have been parsed, this commit moves
parsing from pattern evaluation time to pattern key construction time.

This leads toward more efficient processing of target patterns in
target pattern sequence evaluation.

--
MOS_MIGRATED_REVID=94025646

1 files changed, 27 insertions, 22 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java b/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java
index deeec7940c..dee9659e8d 100644
--- a/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java
+++ b/src/main/java/com/google/devtools/build/lib/cmdline/TargetPattern.java
@@ -53,6 +53,7 @@ public abstract class TargetPattern implements Serializable {
   private static final Parser DEFAULT_PARSER = new Parser("");
 
   private final Type type;
+  private final String originalPattern;
 
   /**
    * Returns a parser with no offset. Note that the Parser class is immutable, so this method may
@@ -104,9 +105,10 @@ public abstract class TargetPattern implements Serializable {
     return SLASH_JOINER.join(pieces);
   }
 
-  private TargetPattern(Type type) {
+  private TargetPattern(Type type, String originalPattern) {
     // Don't allow inheritance outside this class.
     this.type = type;
+    this.originalPattern = Preconditions.checkNotNull(originalPattern);
   }
 
   /**
@@ -118,6 +120,13 @@ public abstract class TargetPattern implements Serializable {
   }
 
   /**
+   * Return the string that was parsed into this pattern.
+   */
+  public String getOriginalPattern() {
+    return originalPattern;
+  }
+
+  /**
    * Evaluates the current target pattern and returns the result.
    */
   public <T> ResolvedTargets<T> eval(TargetPatternResolver<T> resolver)
@@ -160,8 +169,8 @@ public abstract class TargetPattern implements Serializable {
     private final String targetName;
     private final String directory;
 
-    private SingleTarget(String targetName, String directory) {
-      super(Type.SINGLE_TARGET);
+    private SingleTarget(String targetName, String directory, String originalPattern) {
+      super(Type.SINGLE_TARGET, originalPattern);
       this.targetName = Preconditions.checkNotNull(targetName);
       this.directory = Preconditions.checkNotNull(directory);
     }
@@ -172,7 +181,7 @@ public abstract class TargetPattern implements Serializable {
         throws TargetParsingException, InterruptedException {
       Preconditions.checkArgument(excludedSubdirectories.isEmpty(),
           "Target pattern \"%s\" of type %s cannot be evaluated with excluded subdirectories: %s.",
-          targetName, getType(), excludedSubdirectories);
+          getOriginalPattern(), getType(), excludedSubdirectories);
       return resolver.getExplicitTarget(targetName);
     }
 
@@ -208,8 +217,8 @@ public abstract class TargetPattern implements Serializable {
 
     private final String path;
 
-    private InterpretPathAsTarget(String path) {
-      super(Type.PATH_AS_TARGET);
+    private InterpretPathAsTarget(String path, String originalPattern) {
+      super(Type.PATH_AS_TARGET, originalPattern);
       this.path = normalize(Preconditions.checkNotNull(path));
     }
 
@@ -219,7 +228,7 @@ public abstract class TargetPattern implements Serializable {
         throws TargetParsingException, InterruptedException {
       Preconditions.checkArgument(excludedSubdirectories.isEmpty(),
           "Target pattern \"%s\" of type %s cannot be evaluated with excluded subdirectories: %s.",
-          path, getType(), excludedSubdirectories);
+          getOriginalPattern(), getType(), excludedSubdirectories);
       if (resolver.isPackage(path)) {
         // User has specified a package name. lookout for default target.
         return resolver.getExplicitTarget("//" + path);
@@ -271,7 +280,6 @@ public abstract class TargetPattern implements Serializable {
 
   private static final class TargetsInPackage extends TargetPattern {
 
-    private final String originalPattern;
     private final String pattern;
     private final String suffix;
     private final boolean isAbsolute;
@@ -280,8 +288,7 @@ public abstract class TargetPattern implements Serializable {
 
     private TargetsInPackage(String originalPattern, String pattern, String suffix,
         boolean isAbsolute, boolean rulesOnly, boolean checkWildcardConflict) {
-      super(Type.TARGETS_IN_PACKAGE);
-      this.originalPattern = Preconditions.checkNotNull(originalPattern);
+      super(Type.TARGETS_IN_PACKAGE, originalPattern);
       this.pattern = Preconditions.checkNotNull(pattern);
       this.suffix = Preconditions.checkNotNull(suffix);
       this.isAbsolute = isAbsolute;
@@ -295,14 +302,14 @@ public abstract class TargetPattern implements Serializable {
         throws TargetParsingException, InterruptedException {
       Preconditions.checkArgument(excludedSubdirectories.isEmpty(),
           "Target pattern \"%s\" of type %s cannot be evaluated with excluded subdirectories: %s.",
-          originalPattern, getType(), excludedSubdirectories);
+          getOriginalPattern(), getType(), excludedSubdirectories);
       if (checkWildcardConflict) {
         ResolvedTargets<T> targets = getWildcardConflict(resolver);
         if (targets != null) {
           return targets;
         }
       }
-      return resolver.getTargetsInPackage(originalPattern, removeSuffix(pattern, suffix),
+      return resolver.getTargetsInPackage(getOriginalPattern(), removeSuffix(pattern, suffix),
           rulesOnly);
     }
 
@@ -327,13 +334,13 @@ public abstract class TargetPattern implements Serializable {
       TargetsInPackage that = (TargetsInPackage) o;
       return isAbsolute == that.isAbsolute && rulesOnly == that.rulesOnly
           && checkWildcardConflict == that.checkWildcardConflict
-          && originalPattern.equals(that.originalPattern)
+          && getOriginalPattern().equals(that.getOriginalPattern())
           && pattern.equals(that.pattern) && suffix.equals(that.suffix);
     }
 
     @Override
     public int hashCode() {
-      return Objects.hash(getType(), originalPattern, pattern, suffix, isAbsolute, rulesOnly,
+      return Objects.hash(getType(), getOriginalPattern(), pattern, suffix, isAbsolute, rulesOnly,
           checkWildcardConflict);
     }
 
@@ -373,13 +380,11 @@ public abstract class TargetPattern implements Serializable {
 
   private static final class TargetsBelowDirectory extends TargetPattern {
 
-    private final String originalPattern;
     private final String directory;
     private final boolean rulesOnly;
 
     private TargetsBelowDirectory(String originalPattern, String directory, boolean rulesOnly) {
-      super(Type.TARGETS_BELOW_DIRECTORY);
-      this.originalPattern = Preconditions.checkNotNull(originalPattern);
+      super(Type.TARGETS_BELOW_DIRECTORY, originalPattern);
       this.directory = Preconditions.checkNotNull(directory);
       this.rulesOnly = rulesOnly;
     }
@@ -388,7 +393,7 @@ public abstract class TargetPattern implements Serializable {
     public <T> ResolvedTargets<T> eval(TargetPatternResolver<T> resolver,
         ImmutableSet<String> excludedSubdirectories)
         throws TargetParsingException, InterruptedException {
-      return resolver.findTargetsBeneathDirectory(originalPattern, directory, rulesOnly,
+      return resolver.findTargetsBeneathDirectory(getOriginalPattern(), directory, rulesOnly,
           excludedSubdirectories);
     }
 
@@ -415,13 +420,13 @@ public abstract class TargetPattern implements Serializable {
         return false;
       }
       TargetsBelowDirectory that = (TargetsBelowDirectory) o;
-      return rulesOnly == that.rulesOnly && originalPattern.equals(that.originalPattern)
+      return rulesOnly == that.rulesOnly && getOriginalPattern().equals(that.getOriginalPattern())
           && directory.equals(that.directory);
     }
 
     @Override
     public int hashCode() {
-      return Objects.hash(getType(), originalPattern, directory, rulesOnly);
+      return Objects.hash(getType(), getOriginalPattern(), directory, rulesOnly);
     }
   }
 
@@ -557,7 +562,7 @@ public abstract class TargetPattern implements Serializable {
           String error = "invalid target format '" + originalPattern + "': " + e.getMessage();
           throw new TargetParsingException(error);
         }
-        return new SingleTarget(fullLabel, packageAndTarget.getPackageName());
+        return new SingleTarget(fullLabel, packageAndTarget.getPackageName(), originalPattern);
       }
 
       // This is a stripped-down version of interpretPathAsTarget that does no I/O.  We have a basic
@@ -575,7 +580,7 @@ public abstract class TargetPattern implements Serializable {
         throw new TargetParsingException("Bad target pattern '" + originalPattern + "': " +
             errorMessage);
       }
-      return new InterpretPathAsTarget(pattern);
+      return new InterpretPathAsTarget(pattern, originalPattern);
     }
 
     /**