Internal change

PiperOrigin-RevId: 808534743

Author: krasimirgg

rust/bazel/aspects.bzl

@@ -7,7 +7,6 @@
 
 """This file implements rust_proto_library aspect."""
 
-load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
 load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
 load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
 load("@rules_rust//:version.bzl", RUST_VERSION = "VERSION")
@@ -17,9 +16,6 @@ load("@rules_rust//rust/private:providers.bzl", "CrateInfo", "DepInfo", "DepVari
 
 # buildifier: disable=bzl-visibility
 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")
 
 visibility(["//rust/...", "//third_party/crubit/rs_bindings_from_cc/..."])
 
@@ -34,8 +30,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.",
     },
@@ -50,6 +51,9 @@ def _rust_version_ge(version):
     return _version_parts(RUST_VERSION) >= _version_parts(version)
 
 def label_to_crate_name(ctx, label, toolchain):
+    return compute_crate_name(ctx.workspace_name, label, toolchain)
+
+def encode_label_as_crate_name(label):
     return label.name.replace("-", "_")
 
 def proto_rust_toolchain_label(is_upb):
@@ -226,7 +230,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 +241,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:
@@ -245,7 +250,7 @@ def _compile_rust(ctx, attr, src, extra_srcs, deps, runtime):
     toolchain = ctx.toolchains["@rules_rust//rust:toolchain_type"]
     output_hash = repr(hash(src.path))
 
-    crate_name = label_to_crate_name(ctx, ctx.label, toolchain)
+    crate_name = compute_crate_name(ctx, ctx.label, toolchain)
 
     lib_name = "{prefix}{name}-{lib_hash}{extension}".format(
         prefix = "lib",
@@ -292,7 +297,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 +307,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 +346,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 +443,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 +481,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 2023 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])