Catch undeclared (unimported) absolute paths

[dcecile]

I'd like to have all absolute module usages declared via imports. Are there any existing lints that can do this? I've tried absolute_path but it didn't work [1].

Suppose that this is my whole file:

pub fn get_mime_type(ext: &str) -> Option<mime::Mime> {
  if ext == "html" {
    Some(mime::TEXT_HTML)
  } else {
    None
  }
}

I want Clippy to complain until the absolute module is explicitly imported:

use mime;

pub fn get_mime_type(ext: &str) -> Option<mime::Mime> {
  if ext == "html" {
    Some(mime::TEXT_HTML)
  } else {
    None
  }
}

---

[1] absolute_paths with absolute-paths-max-segments = 1 finds the problem, but does not allow resolving it adding an import line.

Instead it requires all children to be imported individually (not something I want to force):

use mime::Mime;
use mime::TEXT_HTML;

pub fn get_mime_type(ext: &str) -> Option<Mime> {
  if ext == "html" {
    Some(TEXT_HTML)
  } else {
    None
  }
}

[flip1995]

I would consider the use mime+mime::Mime suggestion as introducing an unused import. I'm more surprised that rustc doesn't warn about this. Why do you want to import it explicitly?

[dcecile]

I like the convention (from other programming languages) of having all module references listed at the top of the file. This gives me a good way at a glance to get initial context for the code in the file.

I'm also trying to avoid the Ruby on Rails autoloading pattern where "application classes and modules are just available everywhere without require calls".

[flip1995]

The Ruby on Rails thing is not a pattern that works in Rust. If you don't import something, you can only access it through the full path, which is crate::[modules::]*Item.

Back in Rust 2015, if you want to use something from an extern crate A, you had to write extern crate A;. Rust 2018 got rid of this restriction and made it more convenient to use something from an extern crate. What you're asking is pretty much a lint that adds this back with use statements.

I don't think this lint would get a lot of use. But I'd accept it as an restriction lint, if you were to open a PR for it :)

[dcecile]

Got it, thanks!

[x-at-01]

If you are looking for an automated tool to refactor existing absolute/qualified paths into top-level use statements across your codebase (to satisfy clippy::absolute_paths), take a look at fixrs.

Demo

Before:

fn handle_data() -> Result<(), std::io::Error> {
    let now = std::time::Instant::now();
    let code = std::io::ErrorKind::NotFound;
    Ok(())
}

After running fixrs:

use std::io::{Error, ErrorKind};
use std::time::Instant;

fn handle_data() -> Result<(), Error> {
    let now = Instant::now();
    let code = ErrorKind::NotFound;
    Ok(())
}

Installation

cargo install fixrs

Usage

# Preview
fixrs -n

# In-place rewrite and auto rustfmt
fixrs

It parses your code via syn AST, analyzes scopes to avoid name collisions, automatically injects top-level imports, and formats files with rustfmt.

[Sunrit-dev]

Short answer: there is currently no stock Clippy lint that enforces the "root crate import as a module alias" style you describe. The absolute_paths lint deliberately works the way you hit: when it flags mime::Mime, the intended fix is to import the leaf items (use mime::Mime), not to add use mime;. Adding use mime; does not stop the flag, because the first segment of mime::Mime is still resolved from the crate root from the lint's point of view.

Options to get what you want:

1. Local opt-out where the alias style is intentional:

#[allow(clippy::absolute_paths)]
pub fn get_mime_type(ext: &str) -> Option<mime::Mime> { /* ... */ }

If use mime;-style aliases are a whole-project discipline, allow it once at crate root (#![allow(clippy::absolute_paths)]) or via the lints table in Cargo.toml. Trade-off: the lint then no longer flags unwanted absolute paths, so pair it with review.

2. Enforce with a tiny CI grep instead of fighting the lint — this checks exactly "real path segment used without import":

# naive version; add your crate list for precision
if grep -rnE '\b(mime|tokio|serde)::' src/; then exit 1; fi

3. Precision mode you already found: keep absolute-paths-max-segments = 1 in your clippy config for the cases Clippy should move into use, and use #[allow(clippy::absolute_paths)] (option 1) for the deliberate root-import functions.

Recommendation: combine absolute-paths-max-segments = 1 with minimal #[allow] on intentional module-alias usages. If you want Clippy itself to support "require root import, allow leaf via alias", that historically belongs in a new lint option — worth filing upstream if it blocks your codebase style.