src/librustc_resolve/check_unused.rs

   1 //
   2 // Unused import checking
   3 //
   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
   6 // `use` directives.
   7 //
   8 // Unused trait imports can't be checked until the method resolution. We save
   9 // candidates here, and do the actual check in librustc_typeck/check_unused.rs.
  10 //
  11 // Checking for unused imports is split into three steps:
  12 //
  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
  16 //
  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
  21 //    will remove
  22 //
  23 //  - `check_crate` finally emits the diagnostics based on the data generated
  24 //    in the last step
  25
  26 use crate::Resolver;
  27 use crate::resolve_imports::ImportDirectiveSubclass;
  28
  29 use rustc::util::nodemap::NodeMap;
  30 use rustc::{lint, ty};
  31 use rustc_data_structures::fx::FxHashSet;
  32 use syntax::ast;
  33 use syntax::visit::{self, Visitor};
  34 use syntax_pos::{Span, MultiSpan, DUMMY_SP};
  35
  36 struct UnusedImport<'a> {
  37     use_tree: &'a ast::UseTree,
  38     use_tree_id: ast::NodeId,
  39     item_span: Span,
  40     unused: FxHashSet<ast::NodeId>,
  41 }
  42
  43 impl<'a> UnusedImport<'a> {
  44     fn add(&mut self, id: ast::NodeId) {
  45         self.unused.insert(id);
  46     }
  47 }
  48
  49 struct UnusedImportCheckVisitor<'a, 'b> {
  50     r: &'a mut Resolver<'b>,
  51     /// All the (so far) unused imports, grouped path list
  52     unused_imports: NodeMap<UnusedImport<'a>>,
  53     base_use_tree: Option<&'a ast::UseTree>,
  54     base_id: ast::NodeId,
  55     item_span: Span,
  56 }
  57
  58 impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
  59     // We have information about whether `use` (import) directives are actually
  60     // used now. If an import is not used at all, we signal a lint error.
  61     fn check_import(&mut self, id: ast::NodeId) {
  62         let mut used = false;
  63         self.r.per_ns(|this, ns| used |= this.used_imports.contains(&(id, ns)));
  64         if !used {
  65             if self.r.maybe_unused_trait_imports.contains(&id) {
  66                 // Check later.
  67                 return;
  68             }
  69             self.unused_import(self.base_id).add(id);
  70         } else {
  71             // This trait import is definitely used, in a way other than
  72             // method resolution.
  73             self.r.maybe_unused_trait_imports.remove(&id);
  74             if let Some(i) = self.unused_imports.get_mut(&self.base_id) {
  75                 i.unused.remove(&id);
  76             }
  77         }
  78     }
  79
  80     fn unused_import(&mut self, id: ast::NodeId) -> &mut UnusedImport<'a> {
  81         let use_tree_id = self.base_id;
  82         let use_tree = self.base_use_tree.unwrap();
  83         let item_span = self.item_span;
  84
  85         self.unused_imports
  86             .entry(id)
  87             .or_insert_with(|| UnusedImport {
  88                 use_tree,
  89                 use_tree_id,
  90                 item_span,
  91                 unused: FxHashSet::default(),
  92             })
  93     }
  94 }
  95
  96 impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> {
  97     fn visit_item(&mut self, item: &'a ast::Item) {
  98         self.item_span = item.span;
  99
 100         // Ignore is_public import statements because there's no way to be sure
 101         // whether they're used or not. Also ignore imports with a dummy span
 102         // because this means that they were generated in some fashion by the
 103         // compiler and we don't need to consider them.
 104         if let ast::ItemKind::Use(..) = item.node {
 105             if item.vis.node.is_pub() || item.span.is_dummy() {
 106                 return;
 107             }
 108         }
 109
 110         visit::walk_item(self, item);
 111     }
 112
 113     fn visit_use_tree(&mut self, use_tree: &'a ast::UseTree, id: ast::NodeId, nested: bool) {
 114         // Use the base UseTree's NodeId as the item id
 115         // This allows the grouping of all the lints in the same item
 116         if !nested {
 117             self.base_id = id;
 118             self.base_use_tree = Some(use_tree);
 119         }
 120
 121         if let ast::UseTreeKind::Nested(ref items) = use_tree.kind {
 122             if items.is_empty() {
 123                 self.unused_import(self.base_id).add(id);
 124             }
 125         } else {
 126             self.check_import(id);
 127         }
 128
 129         visit::walk_use_tree(self, use_tree, id);
 130     }
 131 }
 132
 133 enum UnusedSpanResult {
 134     Used,
 135     FlatUnused(Span, Span),
 136     NestedFullUnused(Vec<Span>, Span),
 137     NestedPartialUnused(Vec<Span>, Vec<Span>),
 138 }
 139
 140 fn calc_unused_spans(
 141     unused_import: &UnusedImport<'_>,
 142     use_tree: &ast::UseTree,
 143     use_tree_id: ast::NodeId,
 144 ) -> UnusedSpanResult {
 145     // The full span is the whole item's span if this current tree is not nested inside another
 146     // This tells rustfix to remove the whole item if all the imports are unused
 147     let full_span = if unused_import.use_tree.span == use_tree.span {
 148         unused_import.item_span
 149     } else {
 150         use_tree.span
 151     };
 152     match use_tree.kind {
 153         ast::UseTreeKind::Simple(..) | ast::UseTreeKind::Glob => {
 154             if unused_import.unused.contains(&use_tree_id) {
 155                 UnusedSpanResult::FlatUnused(use_tree.span, full_span)
 156             } else {
 157                 UnusedSpanResult::Used
 158             }
 159         }
 160         ast::UseTreeKind::Nested(ref nested) => {
 161             if nested.len() == 0 {
 162                 return UnusedSpanResult::FlatUnused(use_tree.span, full_span);
 163             }
 164
 165             let mut unused_spans = Vec::new();
 166             let mut to_remove = Vec::new();
 167             let mut all_nested_unused = true;
 168             let mut previous_unused = false;
 169             for (pos, (use_tree, use_tree_id)) in nested.iter().enumerate() {
 170                 let remove = match calc_unused_spans(unused_import, use_tree, *use_tree_id) {
 171                     UnusedSpanResult::Used => {
 172                         all_nested_unused = false;
 173                         None
 174                     }
 175                     UnusedSpanResult::FlatUnused(span, remove) => {
 176                         unused_spans.push(span);
 177                         Some(remove)
 178                     }
 179                     UnusedSpanResult::NestedFullUnused(mut spans, remove) => {
 180                         unused_spans.append(&mut spans);
 181                         Some(remove)
 182                     }
 183                     UnusedSpanResult::NestedPartialUnused(mut spans, mut to_remove_extra) => {
 184                         all_nested_unused = false;
 185                         unused_spans.append(&mut spans);
 186                         to_remove.append(&mut to_remove_extra);
 187                         None
 188                     }
 189                 };
 190                 if let Some(remove) = remove {
 191                     let remove_span = if nested.len() == 1 {
 192                         remove
 193                     } else if pos == nested.len() - 1 || !all_nested_unused {
 194                         // Delete everything from the end of the last import, to delete the
 195                         // previous comma
 196                         nested[pos - 1].0.span.shrink_to_hi().to(use_tree.span)
 197                     } else {
 198                         // Delete everything until the next import, to delete the trailing commas
 199                         use_tree.span.to(nested[pos + 1].0.span.shrink_to_lo())
 200                     };
 201
 202                     // Try to collapse adjacent spans into a single one. This prevents all cases of
 203                     // overlapping removals, which are not supported by rustfix
 204                     if previous_unused && !to_remove.is_empty() {
 205                         let previous = to_remove.pop().unwrap();
 206                         to_remove.push(previous.to(remove_span));
 207                     } else {
 208                         to_remove.push(remove_span);
 209                     }
 210                 }
 211                 previous_unused = remove.is_some();
 212             }
 213             if unused_spans.is_empty() {
 214                 UnusedSpanResult::Used
 215             } else if all_nested_unused {
 216                 UnusedSpanResult::NestedFullUnused(unused_spans, full_span)
 217             } else {
 218                 UnusedSpanResult::NestedPartialUnused(unused_spans, to_remove)
 219             }
 220         }
 221     }
 222 }
 223
 224 impl Resolver<'_> {
 225     crate fn check_unused(&mut self, krate: &ast::Crate) {
 226         for directive in self.potentially_unused_imports.iter() {
 227             match directive.subclass {
 228                 _ if directive.used.get() ||
 229                     directive.vis.get() == ty::Visibility::Public ||
 230                     directive.span.is_dummy() => {
 231                     if let ImportDirectiveSubclass::MacroUse = directive.subclass {
 232                         if !directive.span.is_dummy() {
 233                             self.session.buffer_lint(
 234                                 lint::builtin::MACRO_USE_EXTERN_CRATE,
 235                                 directive.id,
 236                                 directive.span,
 237                                 "deprecated `#[macro_use]` directive used to \
 238                                 import macros should be replaced at use sites \
 239                                 with a `use` statement to import the macro \
 240                                 instead",
 241                             );
 242                         }
 243                     }
 244                 }
 245                 ImportDirectiveSubclass::ExternCrate { .. } => {
 246                     self.maybe_unused_extern_crates.push((directive.id, directive.span));
 247                 }
 248                 ImportDirectiveSubclass::MacroUse => {
 249                     let lint = lint::builtin::UNUSED_IMPORTS;
 250                     let msg = "unused `#[macro_use]` import";
 251                     self.session.buffer_lint(lint, directive.id, directive.span, msg);
 252                 }
 253                 _ => {}
 254             }
 255         }
 256
 257         let mut visitor = UnusedImportCheckVisitor {
 258             r: self,
 259             unused_imports: Default::default(),
 260             base_use_tree: None,
 261             base_id: ast::DUMMY_NODE_ID,
 262             item_span: DUMMY_SP,
 263         };
 264         visit::walk_crate(&mut visitor, krate);
 265
 266         for unused in visitor.unused_imports.values() {
 267             let mut fixes = Vec::new();
 268             let mut spans = match calc_unused_spans(unused, unused.use_tree, unused.use_tree_id) {
 269                 UnusedSpanResult::Used => continue,
 270                 UnusedSpanResult::FlatUnused(span, remove) => {
 271                     fixes.push((remove, String::new()));
 272                     vec![span]
 273                 }
 274                 UnusedSpanResult::NestedFullUnused(spans, remove) => {
 275                     fixes.push((remove, String::new()));
 276                     spans
 277                 }
 278                 UnusedSpanResult::NestedPartialUnused(spans, remove) => {
 279                     for fix in &remove {
 280                         fixes.push((*fix, String::new()));
 281                     }
 282                     spans
 283                 }
 284             };
 285
 286             let len = spans.len();
 287             spans.sort();
 288             let ms = MultiSpan::from_spans(spans.clone());
 289             let mut span_snippets = spans.iter()
 290                 .filter_map(|s| {
 291                     match visitor.r.session.source_map().span_to_snippet(*s) {
 292                         Ok(s) => Some(format!("`{}`", s)),
 293                         _ => None,
 294                     }
 295                 }).collect::<Vec<String>>();
 296             span_snippets.sort();
 297             let msg = format!("unused import{}{}",
 298                             if len > 1 { "s" } else { "" },
 299                             if !span_snippets.is_empty() {
 300                                 format!(": {}", span_snippets.join(", "))
 301                             } else {
 302                                 String::new()
 303                             });
 304
 305             let fix_msg = if fixes.len() == 1 && fixes[0].0 == unused.item_span {
 306                 "remove the whole `use` item"
 307             } else if spans.len() > 1 {
 308                 "remove the unused imports"
 309             } else {
 310                 "remove the unused import"
 311             };
 312
 313             visitor.r.session.buffer_lint_with_diagnostic(
 314                 lint::builtin::UNUSED_IMPORTS,
 315                 unused.use_tree_id,
 316                 ms,
 317                 &msg,
 318                 lint::builtin::BuiltinLintDiagnostics::UnusedImports(fix_msg.into(), fixes),
 319             );
 320         }
 321     }
 322 }