Add rename_first_party_crates and third_party_dir flags (#1056)

Co-authored-by: cfredric <[email protected]>
Co-authored-by: Marcel Hlopko <[email protected]>
Co-authored-by: Marcel Hlopko <[email protected]>

Author: cfredric

docs/BUILD.bazel

@@ -13,6 +13,7 @@ bzl_library(
     ],
     deps = [
         "@bazel_skylib//lib:paths",
+        "@bazel_skylib//rules:common_settings",
         "@rules_proto//proto:defs",
         "@rules_proto//proto:repositories",
     ],

rust/private/rust.bzl

@@ -17,7 +17,7 @@ load("//rust/private:common.bzl", "rust_common")
 load("//rust/private:rustc.bzl", "rustc_compile_action")
 load(
     "//rust/private:utils.bzl",
-    "crate_name_from_attr",
+    "compute_crate_name",
     "dedent",
     "determine_output_hash",
     "expand_dict_value_locations",
@@ -253,7 +253,7 @@ def _rust_library_common(ctx, crate_type):
     else:
         output_hash = None
 
-    crate_name = crate_name_from_attr(ctx.attr)
+    crate_name = compute_crate_name(ctx.label, toolchain, ctx.attr.crate_name)
     rust_lib_name = _determine_lib_name(
         crate_name,
         crate_type,
@@ -297,7 +297,7 @@ def _rust_binary_impl(ctx):
         list: A list of providers. See `rustc_compile_action`
     """
     toolchain = find_toolchain(ctx)
-    crate_name = crate_name_from_attr(ctx.attr)
+    crate_name = compute_crate_name(ctx.label, toolchain, ctx.attr.crate_name)
     _assert_correct_dep_mapping(ctx)
 
     output = ctx.actions.declare_file(ctx.label.name + toolchain.binary_ext)
@@ -432,7 +432,7 @@ def _rust_test_common(ctx, toolchain, output):
     _assert_no_deprecated_attributes(ctx)
     _assert_correct_dep_mapping(ctx)
 
-    crate_name = crate_name_from_attr(ctx.attr)
+    crate_name = compute_crate_name(ctx.label, toolchain, ctx.attr.crate_name)
     crate_type = "bin"
 
     deps = transform_deps(ctx.attr.deps)

rust/private/utils.bzl

@@ -235,7 +235,7 @@ def name_to_crate_name(name):
 
     Note that targets can specify the `crate_name` attribute to customize their
     crate name; in situations where this is important, use the
-    crate_name_from_attr() function instead.
+    compute_crate_name() function instead.
 
     Args:
         name (str): The name of the target.
@@ -257,30 +257,39 @@ def _invalid_chars_in_crate_name(name):
 
     return dict([(c, ()) for c in name.elems() if not (c.isalnum() or c == "_")]).keys()
 
-def crate_name_from_attr(attr):
+def compute_crate_name(label, toolchain, name_override = None):
     """Returns the crate name to use for the current target.
 
     Args:
-        attr (struct): The attributes of the current target.
+        label (struct): The label of the current target.
+        toolchain (struct): The toolchain in use for the target.
+        name_override (String): An optional name to use (as an override of label.name).
 
     Returns:
         str: The crate name to use for this target.
     """
-    if hasattr(attr, "crate_name") and attr.crate_name:
-        invalid_chars = _invalid_chars_in_crate_name(attr.crate_name)
+    if name_override:
+        invalid_chars = _invalid_chars_in_crate_name(name_override)
         if invalid_chars:
             fail("Crate name '{}' contains invalid character(s): {}".format(
-                attr.crate_name,
+                name_override,
                 " ".join(invalid_chars),
             ))
-        return attr.crate_name
+        return name_override
+
+    if toolchain and label and toolchain._rename_first_party_crates:
+        if should_encode_label_in_crate_name(label.package, toolchain._third_party_dir):
+            crate_name = label.name
+        else:
+            crate_name = encode_label_as_crate_name(label.package, label.name)
+    else:
+        crate_name = name_to_crate_name(label.name)
 
-    crate_name = name_to_crate_name(attr.name)
     invalid_chars = _invalid_chars_in_crate_name(crate_name)
     if invalid_chars:
         fail(
             "Crate name '{}' ".format(crate_name) +
-            "derived from Bazel target name '{}' ".format(attr.name) +
+            "derived from Bazel target name '{}' ".format(label.name) +
             "contains invalid character(s): {}\n".format(" ".join(invalid_chars)) +
             "Consider adding a crate_name attribute to set a valid crate name",
         )
@@ -382,3 +391,153 @@ def transform_deps(deps):
         build_info = dep[BuildInfo] if BuildInfo in dep else None,
         cc_info = dep[CcInfo] if CcInfo in dep else None,
     ) for dep in deps]
+
+def should_encode_label_in_crate_name(package, third_party_dir):
+    """Determines if the crate's name should include the Bazel label, encoded.
+
+    Names of third-party crates do not encode the full label.
+
+    Args:
+        package (string): The package in question.
+        third_party_dir (string): The directory in which third-party packages are kept.
+
+    Returns:
+        True if the crate name should encode the label, False otherwise.
+    """
+
+    # TODO(hlopko): This code assumes a monorepo; make it work with external
+    # repositories as well.
+    return ("//" + package + "/").startswith(third_party_dir + "/")
+
+# This is a list of pairs, where the first element of the pair is a character
+# that is allowed in Bazel package or target names but not in crate names; and
+# the second element is an encoding of that char suitable for use in a crate
+# name.
+_encodings = (
+    (":", "colon"),
+    ("!", "bang"),
+    ("%", "percent"),
+    ("@", "at"),
+    ("^", "caret"),
+    ("`", "backtick"),
+    (" ", "space"),
+    ("\"", "quote"),
+    ("#", "hash"),
+    ("$", "dollar"),
+    ("&", "ampersand"),
+    ("'", "backslash"),
+    ("(", "lparen"),
+    (")", "rparen"),
+    ("*", "star"),
+    ("-", "dash"),
+    ("+", "plus"),
+    (",", "comma"),
+    (";", "semicolon"),
+    ("<", "langle"),
+    ("=", "equal"),
+    (">", "rangle"),
+    ("?", "question"),
+    ("[", "lbracket"),
+    ("]", "rbracket"),
+    ("{", "lbrace"),
+    ("|", "pipe"),
+    ("}", "rbrace"),
+    ("~", "tilde"),
+    ("/", "slash"),
+    (".", "dot"),
+)
+
+# For each of the above encodings, we generate two substitution rules: one that
+# ensures any occurrences of the encodings themselves in the package/target
+# aren't clobbered by this translation, and one that does the encoding itself.
+# We also include a rule that protects the clobbering-protection rules from
+# getting clobbered.
+_substitutions = [("_quote", "_quotequote_")] + [
+    subst
+    for (pattern, replacement) in _encodings
+    for subst in (
+        ("_{}_".format(replacement), "_quote{}_".format(replacement)),
+        (pattern, "_{}_".format(replacement)),
+    )
+]
+
+def encode_label_as_crate_name(package, name):
+    """Encodes the package and target names in a format suitable for a crate name.
+
+    Args:
+        package (string): The package of the target in question.
+        name (string): The name of the target in question.
+
+    Returns:
+        A string that encodes the package and target name, to be used as the crate's name.
+    """
+    full_name = package + ":" + name
+    return _replace_all(full_name, _substitutions)
+
+def decode_crate_name_as_label_for_testing(crate_name):
+    """Decodes a crate_name that was encoded by encode_label_as_crate_name.
+
+    This is used to check that the encoding is bijective; it is expected to only
+    be used in tests.
+
+    Args:
+        crate_name (string): The name of the crate.
+
+    Returns:
+        A string representing the Bazel label (package and target).
+    """
+    return _replace_all(crate_name, [(t[1], t[0]) for t in _substitutions])
+
+def _replace_all(string, substitutions):
+    """Replaces occurrences of the given patterns in `string`.
+
+    Args:
+        string (string): the string in which the replacements should be performed.
+        substitutions: the list of patterns and replacements to apply.
+
+    Returns:
+        A string with the appropriate substitutions performed.
+
+    There are a few reasons this looks complicated:
+    * The substitutions are performed with some priority, i.e. patterns that are
+      listed first in `substitutions` are higher priority than patterns that are
+      listed later.
+    * We also take pains to avoid doing replacements that overlap with each
+      other, since overlaps invalidate pattern matches.
+    * To avoid hairy offset invalidation, we apply the substitutions
+      right-to-left.
+    * To avoid the "_quote" -> "_quotequote_" rule introducing new pattern
+      matches later in the string during decoding, we take the leftmost
+      replacement, in cases of overlap.  (Note that no rule can induce new
+      pattern matches *earlier* in the string.) (E.g. "_quotedot_" encodes to
+      "_quotequote_dot_". Note that "_quotequote_" and "_dot_" both occur in
+      this string, and overlap.).
+    """
+
+    # Find the highest-priority pattern matches.
+    plan = {}
+    for subst_index, (pattern, replacement) in enumerate(substitutions):
+        for pattern_start in range(len(string)):
+            if not pattern_start in plan and string.startswith(pattern, pattern_start):
+                plan[pattern_start] = (len(pattern), replacement)
+
+    # Drop replacements that overlap with a replacement earlier in the string.
+    replaced_indices_set = {}
+    leftmost_plan = {}
+    for pattern_start in sorted(plan.keys()):
+        length, _ = plan[pattern_start]
+        pattern_indices = list(range(pattern_start, pattern_start + length))
+        if any([i in replaced_indices_set for i in pattern_indices]):
+            continue
+        replaced_indices_set.update([(i, True) for i in pattern_indices])
+        leftmost_plan[pattern_start] = plan[pattern_start]
+
+    plan = leftmost_plan
+
+    # Execute the replacement plan, working from right to left.
+    for pattern_start in sorted(plan.keys(), reverse = True):
+        length, replacement = plan[pattern_start]
+        after_pattern = pattern_start + length
+        string = string[:pattern_start] + replacement + string[after_pattern:]
+
+    return string

rust/settings/BUILD.bazel

@@ -1,4 +1,5 @@
 load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("@bazel_skylib//rules:common_settings.bzl", "bool_flag", "string_flag")
 load(":incompatible.bzl", "incompatible_flag")
 
 package(default_visibility = ["//visibility:public"])
@@ -15,6 +16,25 @@ incompatible_flag(
     issue = "https://github.com/bazelbuild/rules_rust/issues/1069",
 )
 
+# A flag controlling whether to rename first-party crates such that their names
+# encode the Bazel package and target name, instead of just the target name.
+#
+# First-party vs. third-party crates are identified using the value of
+# //settings:third_party_dir.
+bool_flag(
+    name = "rename_first_party_crates",
+    build_setting_default = False,
+)
+
+# A flag specifying the location of vendored third-party rust crates within this
+# repository that must not be renamed when `rename_1p_crates` is enabled.
+#
+# Must be specified as a Bazel package, e.g. "//some/location/in/repo".
+string_flag(
+    name = "third_party_dir",
+    build_setting_default = "//third_party/rust",
+)
+
 bzl_library(
     name = "rules",
     srcs = glob(["**/*.bzl"]),

rust/toolchain.bzl

@@ -1,5 +1,6 @@
 """The rust_toolchain rule definition and implementation."""
 
+load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
 load("//rust/private:common.bzl", "rust_common")
 load("//rust/private:utils.bzl", "dedent", "find_cc_toolchain", "make_static_lib_symlink")
 load("//rust/settings:incompatible.bzl", "IncompatibleFlagInfo")
@@ -234,6 +235,9 @@ def _rust_toolchain_impl(ctx):
     remove_transitive_libs_from_dep_info = ctx.attr._incompatible_remove_transitive_libs_from_dep_info[IncompatibleFlagInfo]
     disable_custom_test_launcher = ctx.attr._incompatible_disable_custom_test_launcher[IncompatibleFlagInfo]
 
+    rename_first_party_crates = ctx.attr._rename_first_party_crates[BuildSettingInfo].value
+    third_party_dir = ctx.attr._third_party_dir[BuildSettingInfo].value
+
     expanded_stdlib_linkflags = []
     for flag in ctx.attr.stdlib_linkflags:
         expanded_stdlib_linkflags.append(
@@ -286,6 +290,8 @@ def _rust_toolchain_impl(ctx):
         libstd_and_allocator_ccinfo = _make_libstd_and_allocator_ccinfo(ctx, ctx.attr.rust_lib, ctx.attr.allocator_library),
         _incompatible_remove_transitive_libs_from_dep_info = remove_transitive_libs_from_dep_info.enabled,
         _incompatible_disable_custom_test_launcher = disable_custom_test_launcher.enabled,
+        _rename_first_party_crates = rename_first_party_crates,
+        _third_party_dir = third_party_dir,
     )
     return [toolchain]
 
@@ -404,6 +410,12 @@ rust_toolchain = rule(
         "_incompatible_remove_transitive_libs_from_dep_info": attr.label(
             default = "@rules_rust//rust/settings:incompatible_remove_transitive_libs_from_dep_info",
         ),
+        "_rename_first_party_crates": attr.label(
+            default = "@rules_rust//rust/settings:rename_first_party_crates",
+        ),
+        "_third_party_dir": attr.label(
+            default = "@rules_rust//rust/settings:third_party_dir",
+        ),
     },
     toolchains = [
         "@bazel_tools//tools/cpp:toolchain_type",

test/unit/rename_first_party_crates/BUILD.bazel

@@ -0,0 +1,4 @@
+load(":rename_first_party_crates_test.bzl", "rename_first_party_crates_test_suite")
+
+############################ UNIT TESTS #############################
+rename_first_party_crates_test_suite(name = "rename_first_party_crates_test_suite")

test/unit/rename_first_party_crates/lib.rs

@@ -0,0 +1 @@
+

test/unit/rename_first_party_crates/main.rs

@@ -0,0 +1 @@
+fn main() {}

test/unit/rename_first_party_crates/my_third_party_dir/BUILD.bazel

@@ -0,0 +1,7 @@
+load("//rust:defs.bzl", "rust_library")
+
+rust_library(
+    name = "third_party_lib",
+    srcs = ["lib.rs"],
+    visibility = ["//visibility:public"],
+)

test/unit/rename_first_party_crates/my_third_party_dir/lib.rs

@@ -0,0 +1 @@
+