6222a735b0
`hir::Item` has an `ident` field.
- It's always non-empty for these item kinds: `ExternCrate`, `Static`,
`Const`, `Fn`, `Macro`, `Mod`, `TyAlias`, `Enum`, `Struct`, `Union`,
Trait`, TraitAalis`.
- It's always empty for these item kinds: `ForeignMod`, `GlobalAsm`,
`Impl`.
- For `Use`, it is non-empty for `UseKind::Single` and empty for
`UseKind::{Glob,ListStem}`.
All of this is quite non-obvious; the only documentation is a single
comment saying "The name might be a dummy name in case of anonymous
items". Some sites that handle items check for an empty ident, some
don't. This is a very C-like way of doing things, but this is Rust, we
have sum types, we can do this properly and never forget to check for
the exceptional case and never YOLO possibly empty identifiers (or
possibly dummy spans) around and hope that things will work out.
The commit is large but it's mostly obvious plumbing work. Some notable
things.
- A similar transformation makes sense for `ast::Item`, but this is
already a big change. That can be done later.
- Lots of assertions are added to item lowering to ensure that
identifiers are empty/non-empty as expected. These will be removable
when `ast::Item` is done later.
- `ItemKind::Use` doesn't get an `Ident`, but `UseKind::Single` does.
- `lower_use_tree` is significantly simpler. No more confusing `&mut
Ident` to deal with.
- `ItemKind::ident` is a new method, it returns an `Option<Ident>`. It's
used with `unwrap` in a few places; sometimes it's hard to tell
exactly which item kinds might occur. None of these unwraps fail on
the test suite. It's conceivable that some might fail on alternative
input. We can deal with those if/when they happen.
- In `trait_path` the `find_map`/`if let` is replaced with a loop, and
things end up much clearer that way.
- `named_span` no longer checks for an empty name; instead the call site
now checks for a missing identifier if necessary.
- `maybe_inline_local` doesn't need the `glob` argument, it can be
computed in-function from the `renamed` argument.
- `arbitrary_source_item_ordering::check_mod` had a big `if` statement
that was just getting the ident from the item kinds that had one. It
could be mostly replaced by a single call to the new `ItemKind::ident`
method.
- `ItemKind` grows from 56 to 64 bytes, but `Item` stays the same size,
and that's what matters, because `ItemKind` only occurs within `Item`.
86 lines
3.4 KiB
Rust
86 lines
3.4 KiB
Rust
use clippy_utils::diagnostics::{span_lint, span_lint_hir_and_then};
|
|
use clippy_utils::path_res;
|
|
use clippy_utils::ty::implements_trait;
|
|
use rustc_hir::def_id::{DefId, LocalDefId};
|
|
use rustc_hir::{Item, ItemKind};
|
|
use rustc_lint::{LateContext, LateLintPass};
|
|
use rustc_middle::ty::Visibility;
|
|
use rustc_session::declare_lint_pass;
|
|
use rustc_span::sym;
|
|
|
|
declare_clippy_lint! {
|
|
/// ### What it does
|
|
/// Checks for types named `Error` that implement `Error`.
|
|
///
|
|
/// ### Why restrict this?
|
|
/// It can become confusing when a codebase has 20 types all named `Error`, requiring either
|
|
/// aliasing them in the `use` statement or qualifying them like `my_module::Error`. This
|
|
/// hinders comprehension, as it requires you to memorize every variation of importing `Error`
|
|
/// used across a codebase.
|
|
///
|
|
/// ### Example
|
|
/// ```rust,ignore
|
|
/// #[derive(Debug)]
|
|
/// pub enum Error { ... }
|
|
///
|
|
/// impl std::fmt::Display for Error { ... }
|
|
///
|
|
/// impl std::error::Error for Error { ... }
|
|
/// ```
|
|
#[clippy::version = "1.73.0"]
|
|
pub ERROR_IMPL_ERROR,
|
|
restriction,
|
|
"exported types named `Error` that implement `Error`"
|
|
}
|
|
declare_lint_pass!(ErrorImplError => [ERROR_IMPL_ERROR]);
|
|
|
|
impl<'tcx> LateLintPass<'tcx> for ErrorImplError {
|
|
fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
|
|
match item.kind {
|
|
ItemKind::TyAlias(ident, ..)
|
|
if ident.name == sym::Error
|
|
&& is_visible_outside_module(cx, item.owner_id.def_id)
|
|
&& let ty = cx.tcx.type_of(item.owner_id).instantiate_identity()
|
|
&& let Some(error_def_id) = cx.tcx.get_diagnostic_item(sym::Error)
|
|
&& implements_trait(cx, ty, error_def_id, &[]) =>
|
|
{
|
|
span_lint(
|
|
cx,
|
|
ERROR_IMPL_ERROR,
|
|
ident.span,
|
|
"exported type alias named `Error` that implements `Error`",
|
|
);
|
|
},
|
|
ItemKind::Impl(imp)
|
|
if let Some(trait_def_id) = imp.of_trait.and_then(|t| t.trait_def_id())
|
|
&& let Some(error_def_id) = cx.tcx.get_diagnostic_item(sym::Error)
|
|
&& error_def_id == trait_def_id
|
|
&& let Some(def_id) = path_res(cx, imp.self_ty).opt_def_id().and_then(DefId::as_local)
|
|
&& let Some(ident) = cx.tcx.opt_item_ident(def_id.to_def_id())
|
|
&& ident.name == sym::Error
|
|
&& is_visible_outside_module(cx, def_id) =>
|
|
{
|
|
span_lint_hir_and_then(
|
|
cx,
|
|
ERROR_IMPL_ERROR,
|
|
cx.tcx.local_def_id_to_hir_id(def_id),
|
|
ident.span,
|
|
"exported type named `Error` that implements `Error`",
|
|
|diag| {
|
|
diag.span_note(item.span, "`Error` was implemented here");
|
|
},
|
|
);
|
|
},
|
|
_ => {},
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Do not lint private `Error`s, i.e., ones without any `pub` (minus `pub(self)` of course) and
|
|
/// which aren't reexported
|
|
fn is_visible_outside_module(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
|
|
!matches!(
|
|
cx.tcx.visibility(def_id),
|
|
Visibility::Restricted(mod_def_id) if cx.tcx.parent_module_from_def_id(def_id).to_def_id() == mod_def_id
|
|
)
|
|
}
|