pants-backend-cargo 0.1.0__tar.gz

pants_backend_cargo-0.1.0/LICENSE-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Tom Solberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pants_backend_cargo-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.1
+Name: pants_backend_cargo
+Version: 0.1.0
+Summary: A Pants backend for Rust that wraps Cargo: cargo_workspace and cargo_package targets, a hermetic toolchain, kache-cached builds, and package, run, test, fmt and lint through cargo.
+Keywords: pantsbuild,pants,backend,rust,cargo
+Author-Email: Tom Solberg <me@sbg.dev>
+License: MIT License
+         
+         Copyright (c) 2022 Tom Solberg
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+         
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Build Tools
+Project-URL: Repository, https://github.com/tgolsson/pants-backends
+Project-URL: Code, https://github.com/tgolsson/pants-backends/tree/main/pants-plugins/cargo
+Project-URL: Changelog, https://github.com/tgolsson/pants-backends/tree/main/pants-plugins/cargo/CHANGELOG.md
+Requires-Python: >=3.11
+Requires-Dist: pants_backend_cc>=0.1.0
+Requires-Dist: pants_backend_platforms>=0.1.0
+Description-Content-Type: text/markdown
+
+# pants-backend-cargo
+
+A [Pants](https://www.pantsbuild.org) backend for Rust that wraps Cargo rather than replacing
+it: Cargo keeps its package model, its lockfiles and its workspaces, and Pants adds target
+addresses, caching, a hermetic toolchain and the usual goals on top.
+
+This release targets Pants **2.32.x**. Install it with `pants-backend-cargo==0.1.0` in
+`[GLOBAL].plugins` in `pants.toml`, and enable `pants_backend_cargo` in
+`[GLOBAL].backend_packages`.
+
+**Status: alpha.** No stability guarantees until it nears feature completeness.
+
+## Targets
+
+- `cargo_workspace`: the root of a Cargo workspace: `Cargo.toml`, `Cargo.lock`,
+  `rust-toolchain.toml` and `.cargo/config.toml`. Members are found through the manifest's
+  `members` (globs one path segment at a time, less `exclude`) and depend on it. Test
+  executables and clippy run once per workspace. Members cannot inherit from the workspace
+  (`version.workspace = true`, `b = { workspace = true }`): a package's targets are generated
+  from its own manifest alone.
+- `cargo_package`: a package. `cargo metadata` on its manifest generates
+  - `path:name#package` (`cargo_package_impl`): the sources and cargo dependencies, what
+    `fmt` and `lint` act on;
+  - `path:name#library` (`cargo_library`), one `cargo_binary` per `[[bin]]` named after it,
+    one `cargo_test` per `[[test]]`: what `test` runs, and for binaries what `package` and
+    `run` build.
+
+  `dependencies` adds `files`/`resources` targets the build reads (`include_str!`, build
+  script inputs) and packageable targets of other backends whose `package` output the build
+  needs: they are built and staged in the sandbox at their package path for `package`,
+  `run`, `test` and `lint` (not for `fmt` and `generate-lockfiles`). Their own dependencies
+  are their backend's inputs and are not staged. `env` sets `KEY=VALUE` entries for every
+  cargo process whose sandbox holds the package (its own, those of packages depending on it,
+  and the per-workspace `test` build, `fmt` and `lint`), and for the test executables and
+  `run` binaries those build; `{chroot}` is the sandbox root, so
+  `env=["MYLIB_DIR={chroot}/build"]` points a build script at a staged library. `PATH`,
+  `CARGO`, `CARGO_HOME`, `CARGO_TARGET_DIR`, `CARGO_INCREMENTAL`, `RUSTUP_HOME`, `RUSTUP_TOOLCHAIN`,
+  `RUSTC_WRAPPER`, `RUSTFLAGS`, `KACHE_*` and the toolchain's `CARGO_TARGET_<TRIPLE>_LINKER`,
+  `CC_<triple>`, `CXX_<triple>` and `AR_<triple>` are the backend's and rejected. `skip_tests` as
+  usual; `output_path` is the directory under `dist/` (default `path.to.target/`), the file
+  keeps the binary's name. A target with `test = false` in
+  `Cargo.toml` gets `skip_tests`. A `[[bin]]` or `[[test]]` named `package` or `library`, or a
+  bin and a test of the same name, is an error: rename it.
+
+`path` dependencies between packages are inferred. `pants tailor` adds both target types.
+Pants reads nothing `.gitignore` ignores, so a workspace's `.cargo/config.toml` must not be
+(`!/.cargo/` after a `.cargo` rule).
+
+## Toolchain
+
+Nothing from the host's `~/.rustup` or `~/.cargo` is used. `[rustup]` pins rustup-init, which
+installs the toolchain into a named cache shared by every sandbox. The version is
+`[rustup].rust_version` or, unset, the `channel` of the `rust-toolchain.toml` at the build
+root, and must be exact: it is part of every cache key. The components the file lists are
+installed with it; `fmt` and `lint` add `rustfmt` and `clippy`.
+
+Every cargo process runs in a fresh sandbox with its own `target/`, so cargo's own incremental
+state never carries over. Instead, `[kache]` puts [kache](https://github.com/kunobi-ninja/kache)
+in front of rustc: compiled crates are keyed by their inputs and kept in a named cache, and
+unchanged crates are restored rather than rebuilt, across sandboxes and across packages of a
+workspace. Local only, no daemon. `--remap-path-prefix` maps the sandbox root to a fixed
+prefix so rustc's output does not depend on the sandbox path; this sets `RUSTFLAGS`, so a
+`build.rustflags` in `.cargo/config.toml` is not read. Its `[target.<triple>] linker` is only
+for plain `cargo`: under Pants the platform's `cc_toolchain` links (see Platforms).
+
+## Platforms
+
+The backend builds for the `platform` targets of
+[pants-backend-platforms](https://github.com/tgolsson/pants-backends). A `cargo_package`'s
+`platforms` field lists what its binaries can be built for, the host alone when unset; `pants
+package` builds those that are the host or in `[platforms].enabled`, the host's binary at its
+usual path and every other under `dist/<platform>/`, with `.exe` for Windows.
+
+```python
+platform(name="windows-x86_64", os="windows", arch="x86_64")  # builds as x86_64-pc-windows-gnu
+cargo_package(platforms=["linux-x86_64", "windows-x86_64"])
+```
+
+- A `platform` builds as its `rust_target`, by default the triple of its `os` and `arch`
+  (`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, `x86_64-pc-windows-gnu`,
+  `aarch64-apple-darwin`, `x86_64-apple-darwin`). Every enabled platform's target is installed
+  with the toolchain. Another platform's build passes `--target`; the host's does not.
+- The platform's `cc_toolchain` ([pants-backend-cc](https://github.com/tgolsson/pants-backends))
+  links the binary and is cc-rs's compiler for that triple, host included; a cross build also
+  gets the host's for its build scripts and proc macros.
+- A packageable dependency of another backend that builds for platforms (a `cmake_target`)
+  is built for the same platform, and must list it in its own `platforms`. Cargo packages
+  that a binary depends on need no `platforms` of their own.
+- `run`, `test`, `fmt`, `lint` and `generate-lockfiles` build for the host only; `test` and
+  `lint` do not pass `--target`, even for a host whose `rust_target` is not the machine's.
+
+## Goals
+
+- `package`: `cargo build --locked --bin <name>` (`--release` with `[rust].release`), the
+  binary at `dist/<path.to.target>/<name>` or under `output_path`.
+- `run`: the packaged binary, with the `files`, `resources` and staged packages of its closure,
+  but not its cargo sources.
+- `test`: one `cargo test --no-run --workspace` per workspace (or per package outside any),
+  then one process per test executable, so each `cargo_library`, `cargo_binary` and
+  `cargo_test` is its own cached test result. Doctests are not run. The executables run from
+  the package directory with the sources at hand and `CARGO_MANIFEST_DIR` set to it, as
+  `cargo test` does, but a path compiled in through `env!("CARGO_MANIFEST_DIR")` or
+  `env!("CARGO_BIN_EXE_<name>")` names the build sandbox, which is gone when the test runs:
+  read `CARGO_MANIFEST_DIR` with `std::env::var` instead. A target cargo builds no executable
+  for (its `required-features` are off) is skipped with a warning.
+- `fmt` / `lint`: `cargo fmt` (`[rust].skip`) and, with
+  `pants_backend_cargo.backends.clippy`, `cargo clippy` (`[clippy].args`, `[clippy].skip`),
+  once per workspace.
+- `generate-lockfiles`: `cargo update`, never cached across runs; the resolve names are the workspace and package
+  addresses (`pants generate-lockfiles --resolve=path:name#package`), and a member's name
+  updates its workspace's `Cargo.lock`.
+
+## Setup
+
+Install `pants-backend-cargo` in `[GLOBAL].plugins` in `pants.toml`, and enable it:
+
+```toml
+[GLOBAL]
+backend_packages = [
+  "pants_backend_cargo",
+  "pants_backend_cargo.backends.clippy",
+]
+
+[rustup]
+rust_version = "1.97.0"  # or a rust-toolchain.toml at the build root
+
+[clippy]
+args = ["--", "-Dwarnings"]
+
+[kache]
+enabled = true  # the default; false runs rustc bare
+```
+
+Linux and macOS. With no `cc_toolchain` targets, the host's `gcc`, `g++` and `ar` link.
+Declaring `platform` and `cc_toolchain` targets needs `pants_backend_platforms` and
+`pants_backend_cc` in `backend_packages` as well; `pants-backend-cargo` installs both.
+
+## License
+
+MIT ([LICENSE-MIT.txt](LICENSE-MIT.txt)).

pants_backend_cargo-0.1.0/README.md

@@ -0,0 +1,140 @@
+# pants-backend-cargo
+
+A [Pants](https://www.pantsbuild.org) backend for Rust that wraps Cargo rather than replacing
+it: Cargo keeps its package model, its lockfiles and its workspaces, and Pants adds target
+addresses, caching, a hermetic toolchain and the usual goals on top.
+
+This release targets Pants **2.32.x**. Install it with `pants-backend-cargo==0.1.0` in
+`[GLOBAL].plugins` in `pants.toml`, and enable `pants_backend_cargo` in
+`[GLOBAL].backend_packages`.
+
+**Status: alpha.** No stability guarantees until it nears feature completeness.
+
+## Targets
+
+- `cargo_workspace`: the root of a Cargo workspace: `Cargo.toml`, `Cargo.lock`,
+  `rust-toolchain.toml` and `.cargo/config.toml`. Members are found through the manifest's
+  `members` (globs one path segment at a time, less `exclude`) and depend on it. Test
+  executables and clippy run once per workspace. Members cannot inherit from the workspace
+  (`version.workspace = true`, `b = { workspace = true }`): a package's targets are generated
+  from its own manifest alone.
+- `cargo_package`: a package. `cargo metadata` on its manifest generates
+  - `path:name#package` (`cargo_package_impl`): the sources and cargo dependencies, what
+    `fmt` and `lint` act on;
+  - `path:name#library` (`cargo_library`), one `cargo_binary` per `[[bin]]` named after it,
+    one `cargo_test` per `[[test]]`: what `test` runs, and for binaries what `package` and
+    `run` build.
+
+  `dependencies` adds `files`/`resources` targets the build reads (`include_str!`, build
+  script inputs) and packageable targets of other backends whose `package` output the build
+  needs: they are built and staged in the sandbox at their package path for `package`,
+  `run`, `test` and `lint` (not for `fmt` and `generate-lockfiles`). Their own dependencies
+  are their backend's inputs and are not staged. `env` sets `KEY=VALUE` entries for every
+  cargo process whose sandbox holds the package (its own, those of packages depending on it,
+  and the per-workspace `test` build, `fmt` and `lint`), and for the test executables and
+  `run` binaries those build; `{chroot}` is the sandbox root, so
+  `env=["MYLIB_DIR={chroot}/build"]` points a build script at a staged library. `PATH`,
+  `CARGO`, `CARGO_HOME`, `CARGO_TARGET_DIR`, `CARGO_INCREMENTAL`, `RUSTUP_HOME`, `RUSTUP_TOOLCHAIN`,
+  `RUSTC_WRAPPER`, `RUSTFLAGS`, `KACHE_*` and the toolchain's `CARGO_TARGET_<TRIPLE>_LINKER`,
+  `CC_<triple>`, `CXX_<triple>` and `AR_<triple>` are the backend's and rejected. `skip_tests` as
+  usual; `output_path` is the directory under `dist/` (default `path.to.target/`), the file
+  keeps the binary's name. A target with `test = false` in
+  `Cargo.toml` gets `skip_tests`. A `[[bin]]` or `[[test]]` named `package` or `library`, or a
+  bin and a test of the same name, is an error: rename it.
+
+`path` dependencies between packages are inferred. `pants tailor` adds both target types.
+Pants reads nothing `.gitignore` ignores, so a workspace's `.cargo/config.toml` must not be
+(`!/.cargo/` after a `.cargo` rule).
+
+## Toolchain
+
+Nothing from the host's `~/.rustup` or `~/.cargo` is used. `[rustup]` pins rustup-init, which
+installs the toolchain into a named cache shared by every sandbox. The version is
+`[rustup].rust_version` or, unset, the `channel` of the `rust-toolchain.toml` at the build
+root, and must be exact: it is part of every cache key. The components the file lists are
+installed with it; `fmt` and `lint` add `rustfmt` and `clippy`.
+
+Every cargo process runs in a fresh sandbox with its own `target/`, so cargo's own incremental
+state never carries over. Instead, `[kache]` puts [kache](https://github.com/kunobi-ninja/kache)
+in front of rustc: compiled crates are keyed by their inputs and kept in a named cache, and
+unchanged crates are restored rather than rebuilt, across sandboxes and across packages of a
+workspace. Local only, no daemon. `--remap-path-prefix` maps the sandbox root to a fixed
+prefix so rustc's output does not depend on the sandbox path; this sets `RUSTFLAGS`, so a
+`build.rustflags` in `.cargo/config.toml` is not read. Its `[target.<triple>] linker` is only
+for plain `cargo`: under Pants the platform's `cc_toolchain` links (see Platforms).
+
+## Platforms
+
+The backend builds for the `platform` targets of
+[pants-backend-platforms](https://github.com/tgolsson/pants-backends). A `cargo_package`'s
+`platforms` field lists what its binaries can be built for, the host alone when unset; `pants
+package` builds those that are the host or in `[platforms].enabled`, the host's binary at its
+usual path and every other under `dist/<platform>/`, with `.exe` for Windows.
+
+```python
+platform(name="windows-x86_64", os="windows", arch="x86_64")  # builds as x86_64-pc-windows-gnu
+cargo_package(platforms=["linux-x86_64", "windows-x86_64"])
+```
+
+- A `platform` builds as its `rust_target`, by default the triple of its `os` and `arch`
+  (`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, `x86_64-pc-windows-gnu`,
+  `aarch64-apple-darwin`, `x86_64-apple-darwin`). Every enabled platform's target is installed
+  with the toolchain. Another platform's build passes `--target`; the host's does not.
+- The platform's `cc_toolchain` ([pants-backend-cc](https://github.com/tgolsson/pants-backends))
+  links the binary and is cc-rs's compiler for that triple, host included; a cross build also
+  gets the host's for its build scripts and proc macros.
+- A packageable dependency of another backend that builds for platforms (a `cmake_target`)
+  is built for the same platform, and must list it in its own `platforms`. Cargo packages
+  that a binary depends on need no `platforms` of their own.
+- `run`, `test`, `fmt`, `lint` and `generate-lockfiles` build for the host only; `test` and
+  `lint` do not pass `--target`, even for a host whose `rust_target` is not the machine's.
+
+## Goals
+
+- `package`: `cargo build --locked --bin <name>` (`--release` with `[rust].release`), the
+  binary at `dist/<path.to.target>/<name>` or under `output_path`.
+- `run`: the packaged binary, with the `files`, `resources` and staged packages of its closure,
+  but not its cargo sources.
+- `test`: one `cargo test --no-run --workspace` per workspace (or per package outside any),
+  then one process per test executable, so each `cargo_library`, `cargo_binary` and
+  `cargo_test` is its own cached test result. Doctests are not run. The executables run from
+  the package directory with the sources at hand and `CARGO_MANIFEST_DIR` set to it, as
+  `cargo test` does, but a path compiled in through `env!("CARGO_MANIFEST_DIR")` or
+  `env!("CARGO_BIN_EXE_<name>")` names the build sandbox, which is gone when the test runs:
+  read `CARGO_MANIFEST_DIR` with `std::env::var` instead. A target cargo builds no executable
+  for (its `required-features` are off) is skipped with a warning.
+- `fmt` / `lint`: `cargo fmt` (`[rust].skip`) and, with
+  `pants_backend_cargo.backends.clippy`, `cargo clippy` (`[clippy].args`, `[clippy].skip`),
+  once per workspace.
+- `generate-lockfiles`: `cargo update`, never cached across runs; the resolve names are the workspace and package
+  addresses (`pants generate-lockfiles --resolve=path:name#package`), and a member's name
+  updates its workspace's `Cargo.lock`.
+
+## Setup
+
+Install `pants-backend-cargo` in `[GLOBAL].plugins` in `pants.toml`, and enable it:
+
+```toml
+[GLOBAL]
+backend_packages = [
+  "pants_backend_cargo",
+  "pants_backend_cargo.backends.clippy",
+]
+
+[rustup]
+rust_version = "1.97.0"  # or a rust-toolchain.toml at the build root
+
+[clippy]
+args = ["--", "-Dwarnings"]
+
+[kache]
+enabled = true  # the default; false runs rustc bare
+```
+
+Linux and macOS. With no `cc_toolchain` targets, the host's `gcc`, `g++` and `ar` link.
+Declaring `platform` and `cc_toolchain` targets needs `pants_backend_platforms` and
+`pants_backend_cc` in `backend_packages` as well; `pants-backend-cargo` installs both.
+
+## License
+
+MIT ([LICENSE-MIT.txt](LICENSE-MIT.txt)).

pants_backend_cargo-0.1.0/pants_backend_cargo/__init__.py

@@ -0,0 +1 @@
+""" """

pants_backend_cargo-0.1.0/pants_backend_cargo/backends/clippy/__init__.py

@@ -0,0 +1 @@
+""" """

pants_backend_cargo-0.1.0/pants_backend_cargo/backends/clippy/goals/__init__.py

@@ -0,0 +1 @@
+""" """

pants_backend_cargo-0.1.0/pants_backend_cargo/backends/clippy/goals/lint.py

@@ -0,0 +1,94 @@
+"""`pants lint` with clippy: one `cargo clippy` per workspace (or loose package)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pants.core.environments.target_types import EnvironmentField
+from pants.core.goals.lint import LintResult, LintTargetsRequest
+from pants.core.util_rules.partitions import Partition, Partitions
+from pants.engine.intrinsics import execute_process
+from pants.engine.rules import collect_rules, concurrently, implicitly, rule
+from pants.engine.target import FieldSet
+from pants.util.frozendict import FrozenDict
+from pants.util.logging import LogLevel
+from pants_backend_cargo.backends.clippy.subsystem import ClippySubsystem
+from pants_backend_cargo.goals.fmt import RootMetadata, root_of
+from pants_backend_cargo.target_types import CargoPackageNameField, _CargoPackageMarker
+from pants_backend_cargo.util_rules.cargo import CargoProcessRequest, manifest_path
+from pants_backend_cargo.util_rules.platform import CargoPlatformRequest, cargo_platform
+from pants_backend_cargo.util_rules.rustup import install_rust_toolchain
+from pants_backend_cargo.util_rules.sandbox import CargoSourcesRequest, cargo_sources
+from pants_backend_cargo.util_rules.workspace import CargoPackageMapping
+
+from pants_backend_platforms.util_rules.platforms import KnownPlatforms
+
+
+@dataclass(frozen=True)
+class CargoClippyFieldSet(FieldSet):
+    required_fields = (CargoPackageNameField, _CargoPackageMarker)
+
+    environment: EnvironmentField
+
+
+class CargoClippyRequest(LintTargetsRequest):
+    field_set_type = CargoClippyFieldSet
+    tool_subsystem = ClippySubsystem
+
+
+@rule
+async def partition_clippy(
+    request: CargoClippyRequest.PartitionRequest[CargoClippyFieldSet],
+    clippy: ClippySubsystem,
+    mapping: CargoPackageMapping,
+) -> Partitions[CargoClippyFieldSet, RootMetadata]:
+    if clippy.skip:
+        return Partitions()
+    by_root: dict[RootMetadata, list[CargoClippyFieldSet]] = {}
+    for field_set in request.field_sets:
+        by_root.setdefault(root_of(mapping, field_set.address), []).append(field_set)
+    return Partitions(Partition(tuple(fss), root) for root, fss in by_root.items())
+
+
+@rule(desc="Lint with clippy", level=LogLevel.DEBUG)
+async def run_clippy(
+    request: CargoClippyRequest.Batch[CargoClippyFieldSet, RootMetadata],
+    clippy: ClippySubsystem,
+    known: KnownPlatforms,
+) -> LintResult:
+    root = request.partition_metadata
+    toolchain, cargo, sources = await concurrently(
+        install_rust_toolchain(**implicitly()),
+        cargo_platform(CargoPlatformRequest(known.host)),
+        cargo_sources(
+            CargoSourcesRequest(
+                frozenset([root.root]),
+                include_packages=True,
+                platform=known.host,
+                dependent=root.root,
+            )
+        ),
+    )
+    result = await execute_process(
+        **implicitly(
+            CargoProcessRequest(
+                toolchain,
+                (
+                    "clippy",
+                    "--locked",
+                    f"--manifest-path={manifest_path(root.root.spec_path)}",
+                    *(("--workspace",) if root.workspace else ()),
+                    *clippy.args,
+                ),
+                description=f"cargo clippy {root.root}",
+                digest=sources.digest,
+                env=FrozenDict({**sources.env, **cargo.env}),
+                level=LogLevel.INFO,
+            )
+        )
+    )
+    return LintResult.create(request, result)
+
+
+def rules():
+    return [*collect_rules(), *CargoClippyRequest.rules()]

pants_backend_cargo-0.1.0/pants_backend_cargo/backends/clippy/register.py

@@ -0,0 +1,6 @@
+from pants_backend_cargo.backends.clippy import subsystem
+from pants_backend_cargo.backends.clippy.goals import lint
+
+
+def rules():
+    return [*subsystem.rules(), *lint.rules()]

pants_backend_cargo-0.1.0/pants_backend_cargo/backends/clippy/subsystem.py

@@ -0,0 +1,15 @@
+from pants.option.option_types import ArgsListOption, SkipOption
+from pants.option.subsystem import Subsystem
+
+
+class ClippySubsystem(Subsystem):
+    options_scope = "clippy"
+    name = "clippy"
+    help = "Settings for clippy."
+
+    skip = SkipOption("lint")
+    args = ArgsListOption(example="-- -D warnings")
+
+
+def rules():
+    return ClippySubsystem.rules()

pants_backend_cargo-0.1.0/pants_backend_cargo/goals/__init__.py

@@ -0,0 +1 @@
+""" """

pants_backend_cargo-0.1.0/pants_backend_cargo/goals/fmt.py

@@ -0,0 +1,122 @@
+"""`pants fmt` with rustfmt: one `cargo fmt` per workspace (or loose package)."""
+
+from __future__ import annotations
+
+import glob
+from dataclasses import dataclass
+
+from pants.core.environments.target_types import EnvironmentField
+from pants.core.goals.fmt import FmtResult, FmtTargetsRequest
+from pants.core.util_rules.partitions import Partition, PartitionerType, Partitions
+from pants.core.util_rules.source_files import SourceFilesRequest, determine_source_files
+from pants.engine.addresses import Address
+from pants.engine.fs import CreateDigest, FileEntry, MergeDigests
+from pants.engine.intrinsics import create_digest, get_digest_entries, merge_digests
+from pants.engine.process import fallible_to_exec_result_or_raise
+from pants.engine.rules import collect_rules, concurrently, implicitly, rule
+from pants.engine.target import FieldSet
+from pants.util.logging import LogLevel
+from pants_backend_cargo.subsystems import RustSubsystem
+from pants_backend_cargo.target_types import CargoPackageNameField, CargoPackageSourcesField
+from pants_backend_cargo.util_rules.cargo import CargoProcessRequest, manifest_path
+from pants_backend_cargo.util_rules.rustup import install_rust_toolchain
+from pants_backend_cargo.util_rules.sandbox import CargoSourcesRequest, cargo_sources
+from pants_backend_cargo.util_rules.workspace import CargoPackageMapping
+
+from pants_backend_platforms.util_rules.platforms import KnownPlatforms
+
+
+@dataclass(frozen=True)
+class CargoFmtFieldSet(FieldSet):
+    required_fields = (CargoPackageSourcesField, CargoPackageNameField)
+
+    sources: CargoPackageSourcesField
+    environment: EnvironmentField
+
+
+class CargoFmtRequest(FmtTargetsRequest):
+    field_set_type = CargoFmtFieldSet
+    partitioner_type = PartitionerType.CUSTOM
+    tool_subsystem = RustSubsystem
+
+
+@dataclass(frozen=True)
+class RootMetadata:
+    """A workspace (or a package outside any), the unit cargo fmt and clippy run on."""
+
+    root: Address
+    workspace: bool
+
+    @property
+    def description(self) -> str:
+        return str(self.root)
+
+
+def root_of(mapping: CargoPackageMapping, package: Address) -> RootMetadata:
+    workspace = mapping.workspace_for(package)
+    return RootMetadata(workspace or package, workspace is not None)
+
+
+@rule
+async def partition_cargo_fmt(
+    request: CargoFmtRequest.PartitionRequest[CargoFmtFieldSet],
+    rust: RustSubsystem,
+    mapping: CargoPackageMapping,
+) -> Partitions[str, RootMetadata]:
+    if rust.skip:
+        return Partitions()
+    all_sources = await concurrently(
+        determine_source_files(SourceFilesRequest([fs.sources])) for fs in request.field_sets
+    )
+    by_root: dict[RootMetadata, set[str]] = {}
+    for field_set, sources in zip(request.field_sets, all_sources):
+        files = by_root.setdefault(root_of(mapping, field_set.address), set())
+        files.update(f for f in sources.files if f.endswith(".rs"))
+    return Partitions(Partition(tuple(sorted(files)), root) for root, files in by_root.items() if files)
+
+
+@rule(desc="Format with cargo fmt", level=LogLevel.DEBUG)
+async def cargo_fmt(request: CargoFmtRequest.Batch[str, RootMetadata], known: KnownPlatforms) -> FmtResult:
+    root = request.partition_metadata
+    toolchain, sources = await concurrently(
+        install_rust_toolchain(**implicitly()),
+        cargo_sources(
+            CargoSourcesRequest(
+                frozenset([root.root]),
+                include_packages=False,
+                platform=known.host,
+                dependent=root.root,
+            )
+        ),
+    )
+    # The batch's files come from the fmt chain (an earlier formatter may have changed them);
+    # everything else cargo needs comes from the sources.
+    # A file name may hold glob characters (`src/[gen].rs`): the batch's files leave the
+    # sources by exact path, and their outputs are captured escaped.
+    batch = set(request.files)
+    entries = await get_digest_entries(sources.digest)
+    others = await create_digest(
+        CreateDigest(e for e in entries if not (isinstance(e, FileEntry) and e.path in batch))
+    )
+    input_digest = await merge_digests(MergeDigests([others, request.snapshot.digest]))
+    result = await fallible_to_exec_result_or_raise(
+        **implicitly(
+            CargoProcessRequest(
+                toolchain,
+                (
+                    "fmt",
+                    f"--manifest-path={manifest_path(root.root.spec_path)}",
+                    *(("--all",) if root.workspace else ()),
+                ),
+                description=f"cargo fmt {root.root}",
+                digest=input_digest,
+                output_files=tuple(glob.escape(f) for f in request.files),
+                env=sources.env,
+            )
+        )
+    )
+    return await FmtResult.create(request, result)
+
+
+def rules():
+    return [*collect_rules(), *CargoFmtRequest.rules()]