How to register a custom driver with cargo?

[benwu25]

Is there a way for people to write their own custom drivers like clippy? 6356 suggests it is not built in. Can people copy how clippy integrates with cargo, or is it not possible since clippy is shipped with cargo?
Thanks.

[y21]

Yes, anyone can copy what clippy is doing, clippy is not special in this regard. You can invoke cargo with the RUSTC env variable pointing to your driver's executable and it will invoke your custom driver on every crate instead of running rustc directly, like RUSTC=path-to-your-driver-executable cargo check. Then if you wanted to write a linter like clippy you'd define your own callbacks and in fn config you register some extra lints that run on top of the builtin ones, and use run_compiler() to start the compilation session with said callbacks.

[flip1995]

The TL;DR version I tell people when asking the question: Just copy the src/ folder from Clippy and adjust to your needs.

There are 2 things special for Clippy:

1. It is build together with rustc in the Rust repo, so it works on "stable".
2. Without #![register_{attribute,lint}_tool] rfcs#3808 you won't be able to easily write your own linter with namespaced lints.

[benwu25]

Awesome, I will start doing this with my project.

[benwu25]

@y21 @flip1995 Hi, if my driver is invoked via rustup run nightly /path/to/driver, how can I tell the RUSTC environment variable about this? I don't see a way to link the right libraries, and something like RUSTC=['rustup', 'run', 'nightly', '/path/to/driver'] also doesn't work, even if I add it do ~/.cargo/config.toml. How does clippy link libraries to the driver and use the RUSTC environment variable?

Should I compile my driver to automatically link to the rustc_driver libraries?

[Alexendoo]

For a custom driver you'd have a specific nightly you're installed for, so you'd want to invoke RUSTC_WORKSPACE_WRAPPER=/path/to/driver/ cargo check +nightly-xxx (or the equivalent rustup run)

Clippy doesn't need to set the toolchain explicitly since it's distributed as part of rustup, but your command would so that the user doesn't need to be on the same exact nightly

How does clippy link libraries to the driver and use the RUSTC environment variable?

We use RUSTC_WORKSPACE_WRAPPER rather than RUSTC as we don't want to run on dependencies, the command is built here by cargo-clippy

rust-clippy/src/main.rs

Lines 53 to 127 in 8d6de0b

	struct ClippyCmd {
	cargo_subcommand: &'static str,
	args: Vec<String>,
	clippy_args: Vec<String>,
	}
	impl ClippyCmd {
	fn new<I>(mut old_args: I) -> Self
	where
	I: Iterator<Item = String>,
	{
	let mut cargo_subcommand = "check";
	let mut args = vec![];
	let mut clippy_args: Vec<String> = vec![];
	for arg in old_args.by_ref() {
	match arg.as_str() {
	"--fix" => {
	cargo_subcommand = "fix";
	continue;
	},
	"--no-deps" => {
	clippy_args.push("--no-deps".into());
	continue;
	},
	"--" => break,
	_ => {},
	}
	args.push(arg);
	}
	clippy_args.append(&mut (old_args.collect()));
	if cargo_subcommand == "fix" && !clippy_args.iter().any(|arg| arg == "--no-deps") {
	clippy_args.push("--no-deps".into());
	}
	Self {
	cargo_subcommand,
	args,
	clippy_args,
	}
	}
	fn path() -> PathBuf {
	let mut path = env::current_exe()
	.expect("current executable path invalid")
	.with_file_name("clippy-driver");
	if cfg!(windows) {
	path.set_extension("exe");
	}
	path
	}
	fn into_std_cmd(self) -> Command {
	let mut cmd = Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()));
	let clippy_args: String = self
	.clippy_args
	.iter()
	.fold(String::new(), |s, arg| s + arg + "__CLIPPY_HACKERY__");
	// Currently, `CLIPPY_TERMINAL_WIDTH` is used only to format "unknown field" error messages.
	let terminal_width = termize::dimensions().map_or(0, |(w, _)| w);
	cmd.env("RUSTC_WORKSPACE_WRAPPER", Self::path())
	.env("CLIPPY_ARGS", clippy_args)
	.env("CLIPPY_TERMINAL_WIDTH", terminal_width.to_string())
	.arg(self.cargo_subcommand)
	.args(&self.args);
	cmd
	}
	}

For the clippy-driver distributes through rustup on unix linker args are used to specify the runpath https://github.com/rust-lang/rust/blob/64b185eddaa1d7ddf5e0c024be23b9cbba6c1722/src/bootstrap/src/core/builder/cargo.rs#L216-L265, on Windows there's no such equivalent so the rustc_driver & std DLLs are placed in the bin dir

For the binaries produced in this repo that's not the case though, if you cargo build and run ./target/debug/clippy-driver directly you'll see something like

./target/debug/clippy-driver: error while loading shared libraries: librustc_driver-0decb3a692d8391c.so: cannot open shared object file: No such file or directory

But cargo run --bin clippy-driver does work, this is because the cargo here is the rustup proxy, and rustup sets up the environment as required (LD_LIBRARY_PATH/DYLD_FALLBACK_LIBRARY_PATH/PATH) to find the dynamic libraries

So if you're fine with requiring rustup, running cargo check through rustup is sufficient for your driver to locate the dylibs, you just have to ensure the cargo check you're invoking is for the right toolchain