Rust: make generated code refer to ::protobuf instead of ::__pb

This required a tweak to the Bazel aspect to make it alias the appropriate
runtime (C++ or upb) under the name `protobuf`.

The nice thing about this is that it allows the same generated code to work
with both Bazel and Cargo. With Bazel the runtime crate is named `protobuf_cpp`
or `protobuf_upb`, whereas with the Cargo build it is just `protobuf`.

PiperOrigin-RevId: 703143472

rust/aspects.bzl

@@ -197,7 +197,7 @@ def _compile_cc(
         linking_context = linking_context,
     )
 
-def _compile_rust(ctx, attr, src, extra_srcs, deps):
+def _compile_rust(ctx, attr, src, extra_srcs, deps, runtime):
     """Compiles a Rust source file.
 
     Eventually this function could be upstreamed into rules_rust and be made present in rust_common.
@@ -208,6 +208,7 @@ def _compile_rust(ctx, attr, src, extra_srcs, deps):
       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.
+      runtime: The protobuf runtime target.
 
     Returns:
       A DepVariantInfo provider.
@@ -246,7 +247,11 @@ def _compile_rust(ctx, attr, src, extra_srcs, deps):
             srcs = depset([src] + extra_srcs),
             deps = depset(deps),
             proc_macro_deps = depset([]),
-            aliases = {},
+            # Make "protobuf" into an alias for the runtime. This allows the
+            # 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"},
             output = lib,
             metadata = rmeta,
             edition = "2021",
@@ -355,6 +360,7 @@ def _rust_proto_aspect_common(target, ctx, is_upb):
             src = gencode[0],
             extra_srcs = gencode[1:],
             deps = [dep_variant_info_for_runtime, dep_variant_info_for_native_gencode] + dep_variant_infos,
+            runtime = runtime,
         )
         return [RustProtoInfo(
             dep_variant_infos = [dep_variant_info],

rust/release_crates/protobuf_codegen/src/lib.rs

@@ -140,11 +140,7 @@ impl CodeGen {
 
     // Adjust the generated Rust code to work with the crate structure.
     fn fix_rs_gencode(path: &Path) {
-        let contents = fs::read_to_string(path)
-            .unwrap()
-            .replace("crate::", "")
-            .replace("protobuf_upb", "protobuf")
-            .replace("::__pb", "__pb");
+        let contents = fs::read_to_string(path).unwrap().replace("crate::", "");
         let mut file = OpenOptions::new().write(true).truncate(true).open(path).unwrap();
         file.write(contents.as_bytes()).unwrap();
     }

src/google/protobuf/compiler/rust/generator.cc

@@ -148,20 +148,15 @@ bool RustGenerator::Generate(const FileDescriptor* file,
   // Convenience shorthands for common symbols.
   auto v = ctx.printer().WithVars({
       {"std", "::std"},
-      {"pb", "::__pb"},
-      {"pbi", "::__pb::__internal"},
-      {"pbr", "::__pb::__runtime"},
+      {"pb", "::protobuf"},
+      {"pbi", "::protobuf::__internal"},
+      {"pbr", "::protobuf::__runtime"},
       {"NonNull", "::std::ptr::NonNull"},
       {"Phantom", "::std::marker::PhantomData"},
       {"Result", "::std::result::Result"},
       {"Option", "::std::option::Option"},
   });
 
-  ctx.Emit({{"kernel", KernelRsName(ctx.opts().kernel)}}, R"rs(
-    extern crate protobuf_$kernel$ as __pb;
-
-  )rs");
-
   std::vector<const FileDescriptor*> file_contexts(
       files_in_current_crate.begin(), files_in_current_crate.end());
 

src/google/protobuf/compiler/rust/naming.cc

@@ -140,9 +140,9 @@ std::string RsTypePath(Context& ctx, const FieldDescriptor& field) {
     case RustFieldType::DOUBLE:
       return "f64";
     case RustFieldType::BYTES:
-      return "::__pb::ProtoBytes";
+      return "::protobuf::ProtoBytes";
     case RustFieldType::STRING:
-      return "::__pb::ProtoString";
+      return "::protobuf::ProtoString";
     case RustFieldType::MESSAGE:
       return GetFullyQualifiedPath(ctx, *field.message_type());
     case RustFieldType::ENUM:
@@ -169,7 +169,7 @@ std::string RsViewType(Context& ctx, const FieldDescriptor& field,
     case RustFieldType::BYTES:
       return absl::StrFormat("&%s [u8]", lifetime);
     case RustFieldType::STRING:
-      return absl::StrFormat("&%s ::__pb::ProtoStr", lifetime);
+      return absl::StrFormat("&%s ::protobuf::ProtoStr", lifetime);
     case RustFieldType::MESSAGE:
       if (lifetime.empty()) {
         return absl::StrFormat(

src/google/protobuf/compiler/rust/oneof.cc

@@ -116,11 +116,13 @@ std::string RsTypeNameView(Context& ctx, const FieldDescriptor& field) {
     case RustFieldType::BYTES:
       return "&'msg [u8]";
     case RustFieldType::STRING:
-      return "&'msg ::__pb::ProtoStr";
+      return "&'msg ::protobuf::ProtoStr";
     case RustFieldType::MESSAGE:
-      return absl::StrCat("::__pb::View<'msg, ", RsTypePath(ctx, field), ">");
+      return absl::StrCat("::protobuf::View<'msg, ", RsTypePath(ctx, field),
+                          ">");
     case RustFieldType::ENUM:
-      return absl::StrCat("::__pb::View<'msg, ", RsTypePath(ctx, field), ">");
+      return absl::StrCat("::protobuf::View<'msg, ", RsTypePath(ctx, field),
+                          ">");
   }
 
   ABSL_LOG(FATAL) << "Unexpected field type: " << field.type_name();