Implement prost

Author: dzbarsky

MODULE.bazel

@@ -51,13 +51,45 @@ bazel_dep(name = "bazel_features", version = "1.32.0")
 bazel_dep(name = "bazel_skylib", version = "1.4.1")
 bazel_dep(name = "package_metadata", version = "0.0.5")
 bazel_dep(name = "platforms", version = "0.0.5")
+bazel_dep(name = "protobuf", version = "34.0.bcr.1", repo_name = "com_google_protobuf")
 bazel_dep(name = "rules_cc", version = "0.2.8")
+bazel_dep(name = "rules_proto", version = "7.1.0")
 bazel_dep(name = "llvm", version = "0.6.7")
 bazel_dep(name = "aspect_tools_telemetry", version = "0.3.2")
 
 tel = use_extension("@aspect_tools_telemetry//:extension.bzl", "telemetry")
 use_repo(tel, "aspect_tools_telemetry_report")
 
+crate = use_extension("//rs:extensions.bzl", "crate")
+crate.from_cargo(
+    name = "rrprd",
+    cargo_lock = "//rs/private/prost:Cargo.lock",
+    cargo_toml = "//rs/private/prost:Cargo.toml",
+    platform_triples = [
+        "aarch64-unknown-linux-gnu",
+        "aarch64-apple-darwin",
+        "aarch64-pc-windows-gnullvm",
+        "aarch64-pc-windows-msvc",
+        "x86_64-unknown-linux-gnu",
+        "x86_64-apple-darwin",
+        "x86_64-pc-windows-gnullvm",
+        "x86_64-pc-windows-msvc",
+    ],
+    use_experimental_platforms = True,
+)
+crate.annotation(
+    crate = "protoc-gen-prost",
+    gen_binaries = ["protoc-gen-prost"],
+)
+crate.annotation(
+    crate = "protoc-gen-tonic",
+    gen_binaries = ["protoc-gen-tonic"],
+)
+use_repo(crate, "rrprd")
+
+rules_rust_prost = use_extension("//rs/experimental:rules_rust_prost.bzl", "rules_rust_prost")
+use_repo(rules_rust_prost, "rules_rust_prost")
+
 bazel_dep(name = "rules_go", version = "0.59.0", dev_dependency = True)
 bazel_dep(name = "gazelle", version = "0.47.0", dev_dependency = True)
 bazel_dep(name = "bazel_skylib_gazelle_plugin", version = "1.8.2", dev_dependency = True)

MODULE.bazel.lock

@@ -165,6 +165,23 @@ If you import `rules_rust` via this extension, existing `load("@rules_rust//..."
 Using this extension is STRONGLY ENCOURAGED because it carries fixes that improve Windows behavior, rust-analyzer integration, and related compatibility work.
 In addition, when using the `rules_rs` toolchains, loading the compilation rules from `@rules_rs` directly and using the extension is REQUIRED for toolchain resolution to work correctly, at least until https://github.com/bazelbuild/rules_rust/pull/3857 is accepted by rules_rust maintainers. See the Migration section for more info.
 
+## Import `rules_rust_prost` from `rules_rs`
+
+`rules_rs` also exports a `rules_rust_prost` module extension for the prost integration:
+
+```bzl
+bazel_dep(name = "rules_proto", version = "7.1.0")
+bazel_dep(name = "protobuf", version = "34.0.bcr.1", repo_name = "com_google_protobuf")
+
+rules_rust_prost = use_extension("@rules_rs//rs/experimental:rules_rust_prost.bzl", "rules_rust_prost")
+use_repo(rules_rust_prost, "rules_rust_prost")
+
+register_toolchains("@rules_rust_prost//:default_prost_toolchain")
+register_toolchains("@//path/to/proto_toolchain")
+```
+
+The default prost toolchain and its cargo dependencies are provided by `rules_rs`. If you need different prost, tonic, or plugin versions, you can still define your own `rust_prost_toolchain` from `@rules_rust_prost//:defs.bzl`.
+
 ## Platform Configuration
 
 For reliable toolchain resolution, ABI choices should be explicit on every platform participating in your build, including the host platform.

README.md

@@ -10,3 +10,12 @@ bzl_library(
         "@bazel_tools//tools/build_defs/repo:utils.bzl",
     ],
 )
+
+bzl_library(
+    name = "rules_rust_prost",
+    srcs = ["rules_rust_prost.bzl"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@bazel_tools//tools/build_defs/repo:local.bzl",
+    ],
+)

rs/experimental/BUILD.bazel

@@ -31,9 +31,9 @@ def _rules_rust_impl(mctx):
 
     http_archive(
         name = "rules_rust",
-        integrity = "sha256-72j2ji/HaSnpKEKM0DZ/HWhk8PD4jZ6aXIIf0ZSuV4Y=",
-        strip_prefix = "rules_rust-af83221c2b87b80b0178bfc7a87da877246644f5",
-        url = "https://github.com/hermeticbuild/rules_rust/archive/af83221c2b87b80b0178bfc7a87da877246644f5.tar.gz",
+        integrity = "sha256-xT7zyL35CDK5b7iKdKL+WchslRZsnXDXuBMHiqVD0ps=",
+        strip_prefix = "rules_rust-7ed8a24a37be47378b8a266ae3016148b9cb5c49",
+        url = "https://github.com/hermeticbuild/rules_rust/archive/7ed8a24a37be47378b8a266ae3016148b9cb5c49.tar.gz",
         patches = patches,
         patch_strip = strip,
     )

rs/experimental/rules_rust.bzl

@@ -0,0 +1,95 @@
+"""Module extension that provisions the rules_rust_prost repository."""
+
+load("@bazel_tools//tools/build_defs/repo:local.bzl", "local_repository")
+
+def _rules_rust_prost_repo_impl(rctx):
+    rctx.file("BUILD.bazel", """\
+load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "defs.bzl",
+    "providers.bzl",
+])
+
+toolchain_type(
+    name = "toolchain_type",
+)
+
+toolchain(
+    name = "default_prost_toolchain",
+    toolchain = "@rules_rs//rs/private/prost:default_prost_toolchain_impl",
+    toolchain_type = ":toolchain_type",
+)
+
+bzl_library(
+    name = "bzl_lib",
+    srcs = [
+        "defs.bzl",
+        "providers.bzl",
+    ],
+    deps = [
+        "@rules_rust_prost_upstream//:bzl_lib",
+    ],
+)
+""")
+
+    rctx.file("defs.bzl", """\
+load(
+    "@rules_rust_prost_upstream//:defs.bzl",
+    _rust_prost_library = "rust_prost_library",
+    _rust_prost_toolchain = "rust_prost_toolchain",
+    _rust_prost_transform = "rust_prost_transform",
+)
+
+rust_prost_library = _rust_prost_library
+rust_prost_toolchain = _rust_prost_toolchain
+rust_prost_transform = _rust_prost_transform
+""")
+
+    rctx.file("private/BUILD.bazel", """\
+alias(
+    name = "protoc_wrapper",
+    actual = "@rules_rs//rs/private/prost:protoc_wrapper",
+    visibility = ["//visibility:public"],
+)
+
+alias(
+    name = "protoc_wrapper_source",
+    actual = "@rules_rust_prost_upstream//private:protoc_wrapper.rs",
+    visibility = ["//visibility:public"],
+)
+""")
+
+    rctx.file("providers.bzl", """\
+load("@rules_rust_prost_upstream//:providers.bzl", _ProstProtoInfo = "ProstProtoInfo")
+
+ProstProtoInfo = _ProstProtoInfo
+""")
+
+    return rctx.repo_metadata(reproducible = True)
+
+_rules_rust_prost_repo = repository_rule(
+    implementation = _rules_rust_prost_repo_impl,
+)
+
+def _rules_rust_prost_impl(mctx):
+    local_repository(
+        name = "rules_rust_prost_upstream",
+        path = str(mctx.path(Label("@rules_rust//:extensions/prost/WORKSPACE.bzlmod")).dirname),
+    )
+
+    _rules_rust_prost_repo(
+        name = "rules_rust_prost",
+    )
+
+    return mctx.extension_metadata(
+        root_module_direct_deps = ["rules_rust_prost"],
+        root_module_direct_dev_deps = [],
+        reproducible = True,
+    )
+
+rules_rust_prost = module_extension(
+    implementation = _rules_rust_prost_impl,
+)

rs/experimental/rules_rust_prost.bzl

@@ -821,9 +821,8 @@ crate.annotation(
 
     hub_contents = []
     for name, versions in versions_by_name.items():
-        binaries = annotation_for(annotations, name, version).gen_binaries
-
         for version in versions:
+            binaries = annotation_for(annotations, name, version).gen_binaries
             spoke_repo = _spoke_repo(hub_name, name, version)
 
             hub_contents.append("""
@@ -842,6 +841,8 @@ alias(
         workspace_versions = workspace_dep_versions_by_name.get(name)
         if workspace_versions:
             fq = sorted(workspace_versions)[-1]
+            default_version = fq[len(name) + 1:]
+            binaries = annotation_for(annotations, name, default_version).gen_binaries
 
             hub_contents.append("""
 alias(
@@ -1139,18 +1140,23 @@ def _crate_impl(mctx):
 
     packages_by_hub_name = {}
     cargo_toml_by_hub_name = {}
+    cargo_credentials_by_hub_name = {}
+    annotations_by_hub_name = {}
 
     for mod in mctx.modules:
         if not mod.tags.from_cargo:
             fail("`.from_cargo` is required. Please update %s" % mod.name)
 
         for cfg in mod.tags.from_cargo:
             annotations = build_annotation_map(mod, cfg.name)
+            annotations_by_hub_name[cfg.name] = annotations
             mctx.watch(cfg.cargo_lock)
             mctx.watch(cfg.cargo_toml)
             cargo_toml_by_hub_name[cfg.name] = run_toml2json(mctx, cfg.cargo_toml)
             cargo_lock = run_toml2json(mctx, cfg.cargo_lock)
             parsed_packages = cargo_lock.get("package", [])
+            for package in parsed_packages:
+                package["hub_name"] = cfg.name
             packages_by_hub_name[cfg.name] = parsed_packages
 
             # Process git downloads first because they may require a followup download if the repo is a workspace,
@@ -1169,12 +1175,13 @@ def _crate_impl(mctx):
             else:
                 cargo_credentials = {}
 
+            cargo_credentials_by_hub_name[cfg.name] = cargo_credentials
             start_crate_registry_downloads(mctx, downloader_state, annotations, packages_by_hub_name[cfg.name], cargo_credentials, cfg.debug)
 
     for fetch_state in downloader_state.in_flight_git_crate_fetches_by_url.values():
         fetch_state.download_token.wait()
 
-    download_metadata_for_git_crates(mctx, downloader_state, annotations)
+    download_metadata_for_git_crates(mctx, downloader_state, annotations_by_hub_name)
 
     # TODO(zbarsky): Unfortunate that we block on the download for crates.io even though it's well-known.
     # Should we hardcode it?
@@ -1186,12 +1193,14 @@ def _crate_impl(mctx):
 
     for mod in mctx.modules:
         for cfg in mod.tags.from_cargo:
-            if mctx.is_dev_dependency(cfg):
-                direct_dev_deps.append(cfg.name)
-            else:
-                direct_deps.append(cfg.name)
+            if mod.is_root:
+                if mctx.is_dev_dependency(cfg):
+                    direct_dev_deps.append(cfg.name)
+                else:
+                    direct_deps.append(cfg.name)
 
             hub_packages = packages_by_hub_name[cfg.name]
+            cargo_credentials = cargo_credentials_by_hub_name[cfg.name]
 
             annotations = build_annotation_map(mod, cfg.name)
 

rs/extensions.bzl

@@ -291,10 +291,21 @@ def _compute_strip_prefix(annotation, cargo_toml_json, name):
     # TODO(zbarsky): any more cases to handle here?
     return strip_prefix
 
+def _annotations_for_package(annotations_by_hub_name, package):
+    hub_name = package.get("hub_name")
+    if not hub_name:
+        fail("Missing hub_name for package %s" % package.get("name", "<unknown>"))
+
+    annotations = annotations_by_hub_name.get(hub_name)
+    if annotations == None:
+        fail("Missing annotations for hub %s" % hub_name)
+
+    return annotations
+
 def download_metadata_for_git_crates(
         mctx,
         state,
-        annotations):
+        annotations_by_hub_name):
     for url, fetch_state in state.in_flight_git_crate_fetches_by_url.items():
         cargo_toml_path = _sanitize_path_fragment(url)
         _ensure_cargo_toml_exists(mctx.path(cargo_toml_path), fetch_state)
@@ -304,6 +315,7 @@ def download_metadata_for_git_crates(
 
         for package in fetch_state.packages:
             name = package["name"]
+            annotations = _annotations_for_package(annotations_by_hub_name, package)
 
             if cargo_toml_json.get("package", {}).get("name") != name:
                 annotation = annotation_for(annotations, name, package["version"])
@@ -342,6 +354,7 @@ def download_metadata_for_git_crates(
 
         # TODO(zbarsky): multiple crates?
         first_pkg = clone_state.packages[0]
+        annotations = _annotations_for_package(annotations_by_hub_name, first_pkg)
         annotation = annotation_for(annotations, first_pkg["name"], first_pkg["version"])
         cargo_toml_path = clone_dir.get_child(annotation.workspace_cargo_toml)
         _ensure_cargo_toml_exists(cargo_toml_path, clone_state)
@@ -350,6 +363,7 @@ def download_metadata_for_git_crates(
 
         for package in clone_state.packages:
             name = package["name"]
+            annotations = _annotations_for_package(annotations_by_hub_name, package)
 
             if cargo_toml_json.get("package", {}).get("name") != name:
                 annotation = annotation_for(annotations, name, package["version"])

rs/private/downloader.bzl

@@ -0,0 +1,65 @@
+load("@bazel_skylib//rules:common_settings.bzl", "bool_flag")
+load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_library_group")
+load("@rules_rust_prost//:defs.bzl", "rust_prost_toolchain")
+
+package(default_visibility = ["//visibility:public"])
+
+PROST_RUST_EDITION = "2021"
+
+exports_files([
+    "Cargo.lock",
+    "Cargo.toml",
+])
+
+bool_flag(
+    name = "compile_well_known_types",
+    build_setting_default = True,
+)
+
+config_setting(
+    name = "compile_well_known_types_setting",
+    flag_values = {
+        ":compile_well_known_types": "true",
+    },
+)
+
+rust_binary(
+    name = "protoc_wrapper",
+    srcs = ["@rules_rust_prost//private:protoc_wrapper_source"],
+    edition = PROST_RUST_EDITION,
+    deps = [
+        "@rrprd//:heck-0.5.0",
+        "@rrprd//:prost",
+        "@rrprd//:prost-types",
+    ],
+)
+
+rust_library_group(
+    name = "prost_runtime",
+    deps = [
+        "@rrprd//:prost",
+    ],
+)
+
+rust_library_group(
+    name = "tonic_runtime",
+    deps = [
+        ":prost_runtime",
+        "@rrprd//:tonic",
+    ],
+)
+
+rust_prost_toolchain(
+    name = "default_prost_toolchain_impl",
+    compile_well_known_types = select({
+        ":compile_well_known_types_setting": True,
+        "//conditions:default": False,
+    }),
+    prost_plugin = "@rrprd//:protoc-gen-prost__protoc-gen-prost",
+    prost_plugin_flag = "--plugin=protoc-gen-prost=%s",
+    prost_runtime = ":prost_runtime",
+    prost_types = "@rrprd//:prost-types",
+    tonic_plugin = "@rrprd//:protoc-gen-tonic__protoc-gen-tonic",
+    tonic_plugin_flag = "--plugin=protoc-gen-tonic=%s",
+    tonic_runtime = ":tonic_runtime",
+)