LabelParser.java

// Copyright 2021 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.devtools.build.lib.cmdline;

import com.google.auto.value.AutoValue;
import com.google.common.annotations.VisibleForTesting;
import com.google.devtools.build.lib.util.StringUtilities;
import com.google.errorprone.annotations.FormatMethod;
import javax.annotation.Nullable;

/** Utilities to help parse labels. */
final class LabelParser {
  private LabelParser() {}

  /**
   * Contains the parsed elements of a label string. The parts are validated (they don't contain
   * invalid characters). See {@link #parse} for valid label patterns.
   */
  @AutoValue
  abstract static class Parts {
    /**
     * The {@code @repo} or {@code @@canonical_repo} part of the string (sans any leading
     * {@literal @}s); can be null if it doesn't have such a part (i.e. if it doesn't start with a
     * {@literal @}).
     */
    @Nullable
    abstract String repo();
    /**
     * Whether the repo part is using the canonical repo syntax (two {@literal @}s) or not (one
     * {@literal @}). If there is no repo part, this is false.
     */
    abstract boolean repoIsCanonical();
    /**
     * Whether the package part of the string is prefixed by double-slash. This can only be false if
     * the repo part is missing.
     */
    abstract boolean pkgIsAbsolute();
    /**
     * The package part of the string (sans the leading double-slash, if present; also sans the
     * final '...' segment, if present).
     */
    abstract String pkg();
    /** Whether the package part of the string ends with a '...' segment. */
    abstract boolean pkgEndsWithTripleDots();
    /** The target part of the string (sans colon). */
    abstract String target();
    /** The original unparsed raw string. */
    abstract String raw();

    @VisibleForTesting
    static Parts validateAndCreate(
        @Nullable String repo,
        boolean repoIsCanonical,
        boolean pkgIsAbsolute,
        String pkg,
        boolean pkgEndsWithTripleDots,
        String target,
        String raw)
        throws LabelSyntaxException {
      validateRepoName(repo);
      validatePackageName(pkg, target);
      return new AutoValue_LabelParser_Parts(
          repo,
          repoIsCanonical,
          pkgIsAbsolute,
          pkg,
          pkgEndsWithTripleDots,
          validateAndProcessTargetName(pkg, target, pkgEndsWithTripleDots),
          raw);
    }

    /**
     * Parses a raw label string into parts. The logic can be summarized by the following table:
     *
     * <pre>{@code
     *  raw                  | repo   | repoIs-   | pkgIs-   | pkg       | pkgEndsWith- | target
     *                       |        | Canonical | Absolute |           | TripleDots   |
     * ----------------------+--------+-----------+----------+-----------+--------------+-----------
     * "foo/bar"             | null   | false     | false    | ""        | false        | "foo/bar"
     * "..."                 | null   | false     | false    | ""        | true         | ""
     * "...:all"             | null   | false     | false    | ""        | true         | "all"
     * "foo/..."             | null   | false     | false    | "foo"     | true         | ""
     * "//foo/bar"           | null   | false     | true     | "foo/bar" | false        | "bar"
     * "//foo/..."           | null   | false     | true     | "foo"     | true         | ""
     * "//foo/...:all"       | null   | false     | true     | "foo"     | true         | "all"
     * "//foo/all"           | null   | false     | true     | "foo/all" | false        | "all"
     * "@repo"               | "repo" | false     | true     | ""        | false        | "repo"
     * "@@repo"              | "repo" | true      | true     | ""        | false        | "repo"
     * "@repo//foo/bar"      | "repo" | false     | true     | "foo/bar" | false        | "bar"
     * "@@repo//foo/bar"     | "repo" | true      | true     | "foo/bar" | false        | "bar"
     * ":quux"               | null   | false     | false    | ""        | false        | "quux"
     * "foo/bar:quux"        | null   | false     | false    | "foo/bar" | false        | "quux"
     * "//foo/bar:quux"      | null   | false     | true     | "foo/bar" | false        | "quux"
     * "@repo//foo/bar:quux" | "repo" | false     | true     | "foo/bar" | false        | "quux"
     * }</pre>
     */
    static Parts parse(String rawLabel) throws LabelSyntaxException {
      @Nullable final String repo;
      final boolean repoIsCanonical = rawLabel.startsWith("@@");
      final int startOfPackage;
      final int doubleSlashIndex = rawLabel.indexOf("//");
      final boolean pkgIsAbsolute;
      if (rawLabel.startsWith("@")) {
        if (doubleSlashIndex < 0) {
          // Special case: the label "@foo" is synonymous with "@foo//:foo".
          repo = rawLabel.substring(repoIsCanonical ? 2 : 1);
          return validateAndCreate(
              repo,
              repoIsCanonical,
              /* pkgIsAbsolute= */ true,
              /* pkg= */ "",
              /* pkgEndsWithTripleDots= */ false,
              /* target= */ repo,
              rawLabel);
        } else {
          repo = rawLabel.substring(repoIsCanonical ? 2 : 1, doubleSlashIndex);
          startOfPackage = doubleSlashIndex + 2;
          pkgIsAbsolute = true;
        }
      } else {
        // If the label begins with '//', it's an absolute label. Otherwise, treat it as relative
        // (the command-line kind).
        pkgIsAbsolute = doubleSlashIndex == 0;
        startOfPackage = doubleSlashIndex == 0 ? 2 : 0;
        repo = null;
      }

      final String pkg;
      final String target;
      final int colonIndex = rawLabel.indexOf(':', startOfPackage);
      final String rawPkg =
          rawLabel.substring(startOfPackage, colonIndex >= 0 ? colonIndex : rawLabel.length());
      final boolean pkgEndsWithTripleDots = rawPkg.endsWith("/...") || rawPkg.equals("...");
      if (colonIndex < 0 && pkgEndsWithTripleDots) {
        // Special case: if the entire label ends in '...', the target name is empty.
        pkg = stripTrailingTripleDots(rawPkg);
        target = "";
      } else if (colonIndex < 0 && !pkgIsAbsolute) {
        // Special case: the label "foo/bar" is synonymous with ":foo/bar".
        pkg = "";
        target = rawLabel.substring(startOfPackage);
      } else {
        pkg = stripTrailingTripleDots(rawPkg);
        if (colonIndex >= 0) {
          target = rawLabel.substring(colonIndex + 1);
        } else {
          // Special case: the label "[@repo]//foo/bar" is synonymous with "[@repo]//foo/bar:bar".
          // The target name is the last package segment (works even if `pkg` contains no slash)
          target = pkg.substring(pkg.lastIndexOf('/') + 1);
        }
      }
      return validateAndCreate(
          repo, repoIsCanonical, pkgIsAbsolute, pkg, pkgEndsWithTripleDots, target, rawLabel);
    }

    private static String stripTrailingTripleDots(String pkg) {
      if (pkg.endsWith("/...")) {
        return pkg.substring(0, pkg.length() - 4);
      }
      if (pkg.equals("...")) {
        return "";
      }
      return pkg;
    }

    private static void validateRepoName(@Nullable String repo) throws LabelSyntaxException {
      if (repo != null) {
        RepositoryName.validate(repo);
      }
    }

    private static void validatePackageName(String pkg, String target) throws LabelSyntaxException {
      String pkgError = LabelValidator.validatePackageName(pkg);
      if (pkgError != null) {
        throw syntaxErrorf(
            "invalid package name '%s': %s%s", pkg, pkgError, perhapsYouMeantMessage(pkg, target));
      }
    }

    void checkPkgIsAbsolute() throws LabelSyntaxException {
      if (!pkgIsAbsolute()) {
        throw syntaxErrorf("invalid label '%s': absolute label must begin with '@' or '//'", raw());
      }
    }

    void checkPkgDoesNotEndWithTripleDots() throws LabelSyntaxException {
      if (pkgEndsWithTripleDots()) {
        throw syntaxErrorf("invalid label '%s': package name cannot contain '...'", raw());
      }
    }
  }

  @FormatMethod
  static LabelSyntaxException syntaxErrorf(String format, Object... args) {
    return new LabelSyntaxException(
        StringUtilities.sanitizeControlChars(String.format(format, args)));
  }

  private static String perhapsYouMeantMessage(String pkg, String target) {
    return pkg.endsWith('/' + target) ? " (perhaps you meant \":" + target + "\"?)" : "";
  }

  static String validateAndProcessTargetName(
      String pkg, String target, boolean pkgEndsWithTripleDots) throws LabelSyntaxException {
    if (pkgEndsWithTripleDots && target.isEmpty()) {
      // Allow empty target name if the package part ends in '...'.
      return target;
    }
    String targetError = LabelValidator.validateTargetName(target);
    if (targetError != null) {
      throw syntaxErrorf(
          "invalid target name '%s': %s%s",
          target, targetError, perhapsYouMeantMessage(pkg, target));
    }
    // TODO(bazel-team): This should be an error, but we can't make it one for legacy reasons.
    if (target.endsWith("/.")) {
      return target.substring(0, target.length() - 2);
    }
    return target;
  }
}