2 // Unused import checking
4 // Although this is mostly a lint pass, it lives in here because it depends on
5 // resolve data structures and because it finalises the privacy information for
8 // Unused trait imports can't be checked until the method resolution. We save
9 // candidates here, and do the actual check in rustc_hir_analysis/check_unused.rs.
11 // Checking for unused imports is split into three steps:
13 // - `UnusedImportCheckVisitor` walks the AST to find all the unused imports
14 // inside of `UseTree`s, recording their `NodeId`s and grouping them by
15 // the parent `use` item
17 // - `calc_unused_spans` then walks over all the `use` items marked in the
18 // previous step to collect the spans associated with the `NodeId`s and to
19 // calculate the spans that can be removed by rustfix; This is done in a
20 // separate step to be able to collapse the adjacent spans that rustfix
23 // - `check_crate` finally emits the diagnostics based on the data generated
26 use crate::imports::ImportKind;
27 use crate::module_to_string;
31 use rustc_ast::node_id::NodeMap;
32 use rustc_ast::visit::{self, Visitor};
33 use rustc_data_structures::fx::FxHashSet;
34 use rustc_errors::{pluralize, MultiSpan};
35 use rustc_session::lint::builtin::{MACRO_USE_EXTERN_CRATE, UNUSED_IMPORTS};
36 use rustc_session::lint::BuiltinLintDiagnostics;
37 use rustc_span::{Span, DUMMY_SP};
39 struct UnusedImport<'a> {
40 use_tree: &'a ast::UseTree,
41 use_tree_id: ast::NodeId,
43 unused: FxHashSet<ast::NodeId>,
46 impl<'a> UnusedImport<'a> {
47 fn add(&mut self, id: ast::NodeId) {
48 self.unused.insert(id);
52 struct UnusedImportCheckVisitor<'a, 'b> {
53 r: &'a mut Resolver<'b>,
54 /// All the (so far) unused imports, grouped path list
55 unused_imports: NodeMap<UnusedImport<'a>>,
56 base_use_tree: Option<&'a ast::UseTree>,
61 impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
62 // We have information about whether `use` (import) items are actually
63 // used now. If an import is not used at all, we signal a lint error.
64 fn check_import(&mut self, id: ast::NodeId) {
65 let used = self.r.used_imports.contains(&id);
66 let def_id = self.r.local_def_id(id);
68 if self.r.maybe_unused_trait_imports.contains(&def_id) {
72 self.unused_import(self.base_id).add(id);
74 // This trait import is definitely used, in a way other than
76 self.r.maybe_unused_trait_imports.remove(&def_id);
77 if let Some(i) = self.unused_imports.get_mut(&self.base_id) {
83 fn unused_import(&mut self, id: ast::NodeId) -> &mut UnusedImport<'a> {
84 let use_tree_id = self.base_id;
85 let use_tree = self.base_use_tree.unwrap();
86 let item_span = self.item_span;
88 self.unused_imports.entry(id).or_insert_with(|| UnusedImport {
92 unused: FxHashSet::default(),
97 impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> {
98 fn visit_item(&mut self, item: &'a ast::Item) {
99 self.item_span = item.span_with_attributes();
101 // Ignore is_public import statements because there's no way to be sure
102 // whether they're used or not. Also ignore imports with a dummy span
103 // because this means that they were generated in some fashion by the
104 // compiler and we don't need to consider them.
105 if let ast::ItemKind::Use(..) = item.kind {
106 if item.vis.kind.is_pub() || item.span.is_dummy() {
111 visit::walk_item(self, item);
114 fn visit_use_tree(&mut self, use_tree: &'a ast::UseTree, id: ast::NodeId, nested: bool) {
115 // Use the base UseTree's NodeId as the item id
116 // This allows the grouping of all the lints in the same item
119 self.base_use_tree = Some(use_tree);
122 if let ast::UseTreeKind::Nested(ref items) = use_tree.kind {
123 if items.is_empty() {
124 self.unused_import(self.base_id).add(id);
127 self.check_import(id);
130 visit::walk_use_tree(self, use_tree, id);
134 enum UnusedSpanResult {
136 FlatUnused(Span, Span),
137 NestedFullUnused(Vec<Span>, Span),
138 NestedPartialUnused(Vec<Span>, Vec<Span>),
141 fn calc_unused_spans(
142 unused_import: &UnusedImport<'_>,
143 use_tree: &ast::UseTree,
144 use_tree_id: ast::NodeId,
145 ) -> UnusedSpanResult {
146 // The full span is the whole item's span if this current tree is not nested inside another
147 // This tells rustfix to remove the whole item if all the imports are unused
148 let full_span = if unused_import.use_tree.span == use_tree.span {
149 unused_import.item_span
153 match use_tree.kind {
154 ast::UseTreeKind::Simple(..) | ast::UseTreeKind::Glob => {
155 if unused_import.unused.contains(&use_tree_id) {
156 UnusedSpanResult::FlatUnused(use_tree.span, full_span)
158 UnusedSpanResult::Used
161 ast::UseTreeKind::Nested(ref nested) => {
162 if nested.is_empty() {
163 return UnusedSpanResult::FlatUnused(use_tree.span, full_span);
166 let mut unused_spans = Vec::new();
167 let mut to_remove = Vec::new();
168 let mut all_nested_unused = true;
169 let mut previous_unused = false;
170 for (pos, (use_tree, use_tree_id)) in nested.iter().enumerate() {
171 let remove = match calc_unused_spans(unused_import, use_tree, *use_tree_id) {
172 UnusedSpanResult::Used => {
173 all_nested_unused = false;
176 UnusedSpanResult::FlatUnused(span, remove) => {
177 unused_spans.push(span);
180 UnusedSpanResult::NestedFullUnused(mut spans, remove) => {
181 unused_spans.append(&mut spans);
184 UnusedSpanResult::NestedPartialUnused(mut spans, mut to_remove_extra) => {
185 all_nested_unused = false;
186 unused_spans.append(&mut spans);
187 to_remove.append(&mut to_remove_extra);
191 if let Some(remove) = remove {
192 let remove_span = if nested.len() == 1 {
194 } else if pos == nested.len() - 1 || !all_nested_unused {
195 // Delete everything from the end of the last import, to delete the
197 nested[pos - 1].0.span.shrink_to_hi().to(use_tree.span)
199 // Delete everything until the next import, to delete the trailing commas
200 use_tree.span.to(nested[pos + 1].0.span.shrink_to_lo())
203 // Try to collapse adjacent spans into a single one. This prevents all cases of
204 // overlapping removals, which are not supported by rustfix
205 if previous_unused && !to_remove.is_empty() {
206 let previous = to_remove.pop().unwrap();
207 to_remove.push(previous.to(remove_span));
209 to_remove.push(remove_span);
212 previous_unused = remove.is_some();
214 if unused_spans.is_empty() {
215 UnusedSpanResult::Used
216 } else if all_nested_unused {
217 UnusedSpanResult::NestedFullUnused(unused_spans, full_span)
219 UnusedSpanResult::NestedPartialUnused(unused_spans, to_remove)
226 pub(crate) fn check_unused(&mut self, krate: &ast::Crate) {
227 for import in self.potentially_unused_imports.iter() {
229 _ if import.used.get()
230 || import.expect_vis().is_public()
231 || import.span.is_dummy() =>
233 if let ImportKind::MacroUse = import.kind {
234 if !import.span.is_dummy() {
235 self.lint_buffer.buffer_lint(
236 MACRO_USE_EXTERN_CRATE,
239 "deprecated `#[macro_use]` attribute used to \
240 import macros should be replaced at use sites \
241 with a `use` item to import the macro \
247 ImportKind::ExternCrate { .. } => {
248 let def_id = self.local_def_id(import.id);
249 self.maybe_unused_extern_crates.push((def_id, import.span));
251 ImportKind::MacroUse => {
252 let msg = "unused `#[macro_use]` import";
253 self.lint_buffer.buffer_lint(UNUSED_IMPORTS, import.id, import.span, msg);
259 let mut visitor = UnusedImportCheckVisitor {
261 unused_imports: Default::default(),
263 base_id: ast::DUMMY_NODE_ID,
266 visit::walk_crate(&mut visitor, krate);
268 for unused in visitor.unused_imports.values() {
269 let mut fixes = Vec::new();
270 let mut spans = match calc_unused_spans(unused, unused.use_tree, unused.use_tree_id) {
271 UnusedSpanResult::Used => continue,
272 UnusedSpanResult::FlatUnused(span, remove) => {
273 fixes.push((remove, String::new()));
276 UnusedSpanResult::NestedFullUnused(spans, remove) => {
277 fixes.push((remove, String::new()));
280 UnusedSpanResult::NestedPartialUnused(spans, remove) => {
282 fixes.push((*fix, String::new()));
288 let len = spans.len();
290 let ms = MultiSpan::from_spans(spans.clone());
291 let mut span_snippets = spans
293 .filter_map(|s| match visitor.r.session.source_map().span_to_snippet(*s) {
294 Ok(s) => Some(format!("`{}`", s)),
297 .collect::<Vec<String>>();
298 span_snippets.sort();
302 if !span_snippets.is_empty() {
303 format!(": {}", span_snippets.join(", "))
309 let fix_msg = if fixes.len() == 1 && fixes[0].0 == unused.item_span {
310 "remove the whole `use` item"
311 } else if spans.len() > 1 {
312 "remove the unused imports"
314 "remove the unused import"
317 // If we are in the `--test` mode, suppress a help that adds the `#[cfg(test)]`
318 // attribute; however, if not, suggest adding the attribute. There is no way to
319 // retrieve attributes here because we do not have a `TyCtxt` yet.
320 let test_module_span = if visitor.r.session.opts.test {
323 let parent_module = visitor.r.get_nearest_non_block_module(
324 visitor.r.local_def_id(unused.use_tree_id).to_def_id(),
326 match module_to_string(parent_module) {
330 || module.starts_with("test_")
331 || module.starts_with("tests_")
332 || module.ends_with("_test")
333 || module.ends_with("_tests") =>
335 Some(parent_module.span)
341 visitor.r.lint_buffer.buffer_lint_with_diagnostic(
346 BuiltinLintDiagnostics::UnusedImports(fix_msg.into(), fixes, test_module_span),