Rollup merge of #70038 - DutchGhost:const-forget-tests, r=RalfJung

[rust.git] / src / librustc_resolve / check_unused.rs

diff --git a/src/librustc_resolve/check_unused.rs b/src/librustc_resolve/check_unused.rs
index 659a54b169b3974f91a1787ec53ba7b15bd85572..35876176e3e4b0381381a6404e3392abaa086533 100644 (file)
--- a/src/librustc_resolve/check_unused.rs
+++ b/src/librustc_resolve/check_unused.rs
@@ -3,7 +3,7 @@
 //
 // Although this is mostly a lint pass, it lives in here because it depends on
 // resolve data structures and because it finalises the privacy information for
-// `use` directives.
+// `use` items.
 //
 // Unused trait imports can't be checked until the method resolution. We save
 // candidates here, and do the actual check in librustc_typeck/check_unused.rs.
@@ -23,15 +23,16 @@
 //  - `check_crate` finally emits the diagnostics based on the data generated
 //    in the last step
 
-use crate::imports::ImportDirectiveSubclass;
+use crate::imports::ImportKind;
 use crate::Resolver;
 
-use rustc::{lint, ty};
+use rustc::ty;
 use rustc_ast::ast;
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::visit::{self, Visitor};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::pluralize;
+use rustc_session::lint::builtin::{MACRO_USE_EXTERN_CRATE, UNUSED_IMPORTS};
 use rustc_session::lint::BuiltinLintDiagnostics;
 use rustc_span::{MultiSpan, Span, DUMMY_SP};
 
@@ -58,7 +59,7 @@ struct UnusedImportCheckVisitor<'a, 'b> {
 }
 
 impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
-    // We have information about whether `use` (import) directives are actually
+    // We have information about whether `use` (import) items are actually
     // used now. If an import is not used at all, we signal a lint error.
     fn check_import(&mut self, id: ast::NodeId) {
         let mut used = false;
@@ -223,33 +224,32 @@ fn calc_unused_spans(
 
 impl Resolver<'_> {
     crate fn check_unused(&mut self, krate: &ast::Crate) {
-        for directive in self.potentially_unused_imports.iter() {
-            match directive.subclass {
-                _ if directive.used.get()
-                    || directive.vis.get() == ty::Visibility::Public
-                    || directive.span.is_dummy() =>
+        for import in self.potentially_unused_imports.iter() {
+            match import.kind {
+                _ if import.used.get()
+                    || import.vis.get() == ty::Visibility::Public
+                    || import.span.is_dummy() =>
                 {
-                    if let ImportDirectiveSubclass::MacroUse = directive.subclass {
-                        if !directive.span.is_dummy() {
+                    if let ImportKind::MacroUse = import.kind {
+                        if !import.span.is_dummy() {
                             self.lint_buffer.buffer_lint(
-                                lint::builtin::MACRO_USE_EXTERN_CRATE,
-                                directive.id,
-                                directive.span,
-                                "deprecated `#[macro_use]` directive used to \
+                                MACRO_USE_EXTERN_CRATE,
+                                import.id,
+                                import.span,
+                                "deprecated `#[macro_use]` attribute used to \
                                 import macros should be replaced at use sites \
-                                with a `use` statement to import the macro \
+                                with a `use` item to import the macro \
                                 instead",
                             );
                         }
                     }
                 }
-                ImportDirectiveSubclass::ExternCrate { .. } => {
-                    self.maybe_unused_extern_crates.push((directive.id, directive.span));
+                ImportKind::ExternCrate { .. } => {
+                    self.maybe_unused_extern_crates.push((import.id, import.span));
                 }
-                ImportDirectiveSubclass::MacroUse => {
-                    let lint = lint::builtin::UNUSED_IMPORTS;
+                ImportKind::MacroUse => {
                     let msg = "unused `#[macro_use]` import";
-                    self.lint_buffer.buffer_lint(lint, directive.id, directive.span, msg);
+                    self.lint_buffer.buffer_lint(UNUSED_IMPORTS, import.id, import.span, msg);
                 }
                 _ => {}
             }
@@ -314,7 +314,7 @@ impl Resolver<'_> {
             };
 
             visitor.r.lint_buffer.buffer_lint_with_diagnostic(
-                lint::builtin::UNUSED_IMPORTS,
+                UNUSED_IMPORTS,
                 unused.use_tree_id,
                 ms,
                 &msg,