rust protobuf: use crate name aliases to disambiguate generated dependencies

Previously, whenever a proto_library depends on two proto_library targets with the same name from different packages, there is a possibility for crate name collisions. Collisions caused two different crates to be passed with the same name to a rust compilation action via the rustc --extern flag; result is a rust compilation error.

In addition, the aspect compiled the rust code with `force_all_deps_direct`. This is used to handle transitive public imports in protobuf. That has the effect of passing all transitive crate dependencies as-if they were direct via the rustc --extern flag. This compounds the previous issue, rising the risk for crate name collisions.

Here we address these two issues.

To support transitive public imports without `force_all_deps_direct`, we update the aspect to crawl through the `exports` attribute of proto_library targets and collect the rust providers of transitively exported proto libraries in a new RustProtoInfo.exports_dep_variant_infos field. The generated rust code for a consumer proto_library is then provided the rust providers of the transitively exported dependencies.

To address the crate naming collision amongst dependencies, we update the aspect to automatically compute and use disambiguating crate name aliases. These are crate names that encode the full target label of dependencies, in a matter similar to that rules_rust privately uses for its `rename_first_party_crates` functionality. Crucially, this is implemented in protobuf-rust itself and only affects the consumer side of the generated rust code. This avoids the need to synchronize the details between this and rules_rust; uniformly handles first- and third-party dependencies without the need to maintain an explicit distinction, and avoids some issues like running into system filename limits when trying to encode a long target's label into a crate name at crate creation time.

PiperOrigin-RevId: 855663626

Author: krasimirgg

rust/bazel/aspects.bzl

@@ -20,6 +20,10 @@ load("@rules_rust//rust/private:rustc.bzl", "rustc_compile_action")
 load("//bazel/common:proto_common.bzl", "proto_common")
 load("//bazel/common:proto_info.bzl", "ProtoInfo")
 load("//bazel/private:cc_proto_aspect.bzl", "cc_proto_aspect")
+load(
+    "encode_raw_string_as_crate_name.bzl",
+    "encode_raw_string_as_crate_name",
+)
 
 visibility(["//rust/...", "//third_party/crubit/rs_bindings_from_cc/..."])
 
@@ -34,8 +38,13 @@ CrateMappingInfo = provider(
 RustProtoInfo = provider(
     doc = "Rust protobuf provider info",
     fields = {
-        "dep_variant_infos": "List of DepVariantInfo for the compiled Rust " +
-                             "gencode (also covers its transitive dependencies)",
+        "dep_variant_infos": "List(DepVariantInfo): infos for the compiled Rust gencode. \
+            When the target is a regular proto library, this contains a single element -- the info for the top-level generated code. \
+            When the target is a srcsless proto library, this contains the infos of its dependencies.",
+        "exports_dep_variant_infos": "List(DepVariantInfo): Transitive infos from targets from the proto_library.exports attribute. \
+            When the target is a srcsless proto library, this contains the exports infos from all of its dependencies. \
+            This is a list instead of a depset, since we pass them as direct dependencies when compiling rust code. \
+            We assume the proto exports feature is not widely used in a way where this will lead to unacceptable analysis-time overhead.",
         "crate_mapping": "depset(CrateMappingInfo) containing mappings of all transitive " +
                          "dependencies of the current proto_library.",
     },
@@ -52,6 +61,9 @@ def _rust_version_ge(version):
 def label_to_crate_name(ctx, label, toolchain):
     return label.name.replace("-", "_")
 
+def encode_label_as_crate_name(label):
+    return encode_raw_string_as_crate_name(str(label))
+
 def proto_rust_toolchain_label(is_upb):
     if is_upb:
         return "//rust:proto_rust_upb_toolchain"
@@ -226,7 +238,7 @@ def _compile_cc(
         linking_context = linking_context,
     )
 
-def _compile_rust(ctx, attr, src, extra_srcs, deps, runtime):
+def _compile_rust(ctx, attr, src, extra_srcs, deps, aliases, runtime):
     """Compiles a Rust source file.
 
     Eventually this function could be upstreamed into rules_rust and be made present in rust_common.
@@ -237,6 +249,7 @@ def _compile_rust(ctx, attr, src, extra_srcs, deps, runtime):
       src (File): The crate root source file to be compiled.
       extra_srcs ([File]): Additional source files to include in the crate.
       deps (List[DepVariantInfo]): A list of dependencies needed.
+      aliases (dict[Target, str]): A mapping from dependency target to its crate name.
       runtime: The protobuf runtime target.
 
     Returns:
@@ -292,7 +305,7 @@ def _compile_rust(ctx, attr, src, extra_srcs, deps, runtime):
             # generated code to use a consistent name, even though the actual
             # name of the runtime crate varies depending on the protobuf kernel
             # and build system.
-            aliases = {runtime: "protobuf"},
+            aliases = {runtime: "protobuf"} | aliases,
             output = lib,
             metadata = rmeta,
             edition = "2024",
@@ -302,8 +315,6 @@ def _compile_rust(ctx, attr, src, extra_srcs, deps, runtime):
             compile_data_targets = depset([]),
             owner = ctx.label,
         ),
-        # Needed to make transitive public imports not violate layering.
-        force_all_deps_direct = True,
         output_hash = output_hash,
     )
 
@@ -343,18 +354,36 @@ def _rust_proto_aspect_common(target, ctx, is_upb):
         transitive_crate_mappings.append(rust_proto_info.crate_mapping)
 
     dep_variant_infos = []
-    for info in [d[RustProtoInfo].dep_variant_infos for d in proto_deps]:
-        dep_variant_infos += info
+
+    # Infos of exports of dependencies.
+    dep_exports_dep_variant_infos = []
+
+    for dep in proto_deps:
+        dep_variant_infos += dep[RustProtoInfo].dep_variant_infos
+        dep_exports_dep_variant_infos += dep[RustProtoInfo].exports_dep_variant_infos
 
     # If there are no srcs, then this is an alias library (which in Rust acts as a middle
     # library in a dependency chain). Don't generate any Rust code for it, but do propagate the
     # crate mappings.
     if not proto_srcs:
         return [RustProtoInfo(
             dep_variant_infos = dep_variant_infos,
+            exports_dep_variant_infos = dep_exports_dep_variant_infos,
             crate_mapping = depset(transitive = transitive_crate_mappings),
         )]
 
+    # Add the infos from dependencies' exports, as they are needed to compile the
+    # generated code of this target.
+    dep_variant_infos += dep_exports_dep_variant_infos
+
+    # Exports of this target are the directly and transitively exported
+    # dependencies.
+    exported_proto_deps = getattr(ctx.rule.attr, "exports", [])
+    exports_dep_variant_infos = []
+    for d in exported_proto_deps:
+        exports_dep_variant_infos.extend(d[RustProtoInfo].dep_variant_infos)
+        exports_dep_variant_infos.extend(d[RustProtoInfo].exports_dep_variant_infos)
+
     proto_lang_toolchain = ctx.attr._proto_lang_toolchain[proto_common.ProtoLangToolchainInfo]
     cc_toolchain = find_cpp_toolchain(ctx)
     toolchain = ctx.toolchains["@rules_rust//rust:toolchain_type"]
@@ -422,19 +451,35 @@ def _rust_proto_aspect_common(target, ctx, is_upb):
         for dep in ctx.attr._extra_deps
     ]
 
+    aliases = {}
+
+    for d in dep_variant_infos:
+        label = Label(d.crate_info.owner)
+        target = struct(label = label)
+        qualified_name = encode_label_as_crate_name(label)
+        aliases[target] = qualified_name
+
+    deps = ([dep_variant_info_for_runtime] +
+            dep_variant_info_for_native_gencode +
+            dep_variant_infos +
+            extra_dep_variant_infos +
+            exports_dep_variant_infos)
+
     dep_variant_info = _compile_rust(
         ctx = ctx,
         attr = ctx.rule.attr,
         src = entry_point_rs_output,
         extra_srcs = rs_gencode,
-        deps = [dep_variant_info_for_runtime] + dep_variant_info_for_native_gencode + dep_variant_infos + extra_dep_variant_infos,
+        deps = deps,
+        aliases = aliases,
         runtime = runtime,
     )
     return [RustProtoInfo(
         dep_variant_infos = [dep_variant_info],
+        exports_dep_variant_infos = exports_dep_variant_infos,
         crate_mapping = depset(
             direct = [CrateMappingInfo(
-                crate_name = label_to_crate_name(ctx, target.label, toolchain),
+                crate_name = encode_label_as_crate_name(ctx.label),
                 import_paths = tuple([get_import_path(f) for f in proto_srcs]),
             )],
             transitive = transitive_crate_mappings,
@@ -444,7 +489,7 @@ def _rust_proto_aspect_common(target, ctx, is_upb):
 def _make_proto_library_aspect(is_upb):
     return aspect(
         implementation = (_rust_upb_proto_aspect_impl if is_upb else _rust_cc_proto_aspect_impl),
-        attr_aspects = ["deps"],
+        attr_aspects = ["deps", "exports"],
         requires = ([] if is_upb else [cc_proto_aspect]),
         attrs = {
             "_collect_cc_coverage": attr.label(

rust/bazel/encode_raw_string_as_crate_name.bzl

@@ -0,0 +1,142 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2026 Google LLC.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+"""Implements encode_raw_string_as_crate_name.
+
+Based on an implementation in rules_rust:
+* https://github.com/bazelbuild/rules_rust/blob/cdaf15f5796e3e934b074526272823284bbaed01/rust/private/utils.bzl#L643
+"""
+
+# 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 = (
+    (":", "x"),
+    ("!", "excl"),
+    ("%", "prc"),
+    ("@", "ao"),
+    ("^", "caret"),
+    ("`", "bt"),
+    (" ", "sp"),
+    ("\"", "dq"),
+    ("#", "octo"),
+    ("$", "dllr"),
+    ("&", "amp"),
+    ("'", "sq"),
+    ("(", "lp"),
+    (")", "rp"),
+    ("*", "astr"),
+    ("-", "d"),
+    ("+", "pl"),
+    (",", "cm"),
+    (";", "sm"),
+    ("<", "la"),
+    ("=", "eq"),
+    (">", "ra"),
+    ("?", "qm"),
+    ("[", "lbk"),
+    ("]", "rbk"),
+    ("{", "lbe"),
+    ("|", "pp"),
+    ("}", "rbe"),
+    ("~", "td"),
+    ("/", "y"),
+    (".", "pd"),
+)
+
+# 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 = [("_z", "_zz_")] + [
+    subst
+    for (pattern, replacement) in _encodings
+    for subst in (
+        ("_{}_".format(replacement), "_z{}_".format(replacement)),
+        (pattern, "_{}_".format(replacement)),
+    )
+]
+
+# Expose the substitutions for testing only.
+substitutions_for_testing = _substitutions
+
+def _replace_all(string, substitutions):
+    """Replaces occurrences of the given patterns in `string`.
+
+    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.).
+
+    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.
+    """
+
+    # Find the highest-priority pattern matches for each string index, going
+    # left-to-right and skipping indices that are already involved in a
+    # pattern match.
+    plan = {}
+    matched_indices_set = {}
+    for pattern_start in range(len(string)):
+        if pattern_start in matched_indices_set:
+            continue
+        for (pattern, replacement) in substitutions:
+            if not string.startswith(pattern, pattern_start):
+                continue
+            length = len(pattern)
+            plan[pattern_start] = (length, replacement)
+            matched_indices_set.update([(pattern_start + i, True) for i in range(length)])
+            break
+
+    # 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
+
+def encode_raw_string_as_crate_name(str):
+    """Encodes a string using the above encoding format.
+
+    Args:
+        str (string): The string to be encoded.
+
+    Returns:
+        An encoded version of the input string.
+    """
+    return _replace_all(str, _substitutions)
+
+def decode_crate_name_as_raw_string_for_testing(crate_name):
+    """Decodes a crate_name that was encoded by encode_raw_string_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])

rust/test/BUILD

@@ -5,10 +5,12 @@
 # https://developers.google.com/open-source/licenses/bsd
 
 load("@rules_pkg//pkg:mappings.bzl", "pkg_files", "strip_prefix")
+load("@rules_rust//rust:defs.bzl", "rust_library")
 load("//bazel:proto_library.bzl", "proto_library")
 load(
     "//rust:defs.bzl",
     "rust_cc_proto_library",
+    "rust_proto_library",
     "rust_upb_proto_library",
 )
 
@@ -468,3 +470,72 @@ rust_upb_proto_library(
     testonly = True,
     deps = ["//src/google/protobuf:descriptor_proto"],
 )
+
+proto_library(
+    name = "same_name_direct_deps_proto",
+    testonly = True,
+    srcs = ["same_name_direct_deps.proto"],
+    deps = [
+        "//rust/test/p:parent_proto",
+        "//rust/test/q:parent_proto",
+    ],
+)
+
+rust_proto_library(
+    name = "same_name_direct_deps_rust_proto",
+    testonly = True,
+    deps = [":same_name_direct_deps_proto"],
+)
+
+rust_library(
+    name = "same_name_direct_deps_rust_consumer",
+    testonly = True,
+    srcs = ["same_name_direct_deps_consumer.rs"],
+    deps = [":same_name_direct_deps_rust_proto"],
+)
+
+proto_library(
+    name = "same_name_exported_deps_proto",
+    testonly = True,
+    srcs = ["same_name_exported_deps.proto"],
+    deps = [
+        "//rust/test/p:child_proto",
+        "//rust/test/q:child_proto",
+    ],
+)
+
+rust_proto_library(
+    name = "same_name_exported_deps_rust_proto",
+    testonly = True,
+    deps = [":same_name_exported_deps_proto"],
+)
+
+rust_library(
+    name = "same_name_exported_deps_rust_consumer",
+    testonly = True,
+    srcs = ["same_name_exported_deps_consumer.rs"],
+    deps = [":same_name_exported_deps_rust_proto"],
+)
+
+proto_library(
+    name = "same_name_double_alias_exported_deps_proto",
+    testonly = True,
+    srcs = ["same_name_double_alias_exported_deps.proto"],
+    deps = [
+        "//rust/test/p:grandchild_proto",
+        "//rust/test/q:grandchild_proto",
+    ],
+)
+
+rust_proto_library(
+    name = "same_name_double_alias_exported_deps_rust_proto",
+    testonly = True,
+    deps = [":same_name_double_alias_exported_deps_proto"],
+)
+
+rust_library(
+    name = "same_name_double_alias_exported_deps_rust_consumer",
+    testonly = True,
+    srcs = ["same_name_double_alias_exported_deps_consumer.rs"],
+    deps = [":same_name_double_alias_exported_deps_rust_proto"],
+)

rust/test/encode_raw_string_as_crate_name/BUILD

@@ -0,0 +1,7 @@
+load("encode_raw_string_as_crate_name_test.bzl", "encode_raw_string_as_crate_name_test_suite")
+
+package(
+    default_testonly = 1,
+)
+
+encode_raw_string_as_crate_name_test_suite(name = "encode_raw_string_as_crate_name_tests")