Move diagnostic methods to the dedicated module.

compiler/rustc_resolve/src/diagnostics.rs

@@ -1,11 +1,12 @@
 use std::ptr;
 
-use rustc_ast::{self as ast, Path};
+use rustc_ast::ptr::P;
+use rustc_ast::visit::{self, Visitor};
+use rustc_ast::{self as ast, Crate, ItemKind, ModKind, NodeId, Path, CRATE_NODE_ID};
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::{
+use rustc_errors::struct_span_err;
-    struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed, MultiSpan,
+use rustc_errors::{Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed, MultiSpan};
-};
 use rustc_feature::BUILTIN_ATTRIBUTES;
 use rustc_hir::def::Namespace::{self, *};
 use rustc_hir::def::{self, CtorKind, CtorOf, DefKind, NonMacroAttrKind, PerNS};
@@ -13,6 +14,9 @@ use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 use rustc_hir::PrimTy;
 use rustc_middle::bug;
 use rustc_middle::ty::DefIdTree;
+use rustc_session::lint::builtin::ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE;
+use rustc_session::lint::builtin::MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS;
+use rustc_session::lint::BuiltinLintDiagnostics;
 use rustc_session::Session;
 use rustc_span::edition::Edition;
 use rustc_span::hygiene::MacroKind;
@@ -25,10 +29,11 @@ use tracing::debug;
 use crate::imports::{Import, ImportKind, ImportResolver};
 use crate::late::Rib;
 use crate::path_names_to_string;
-use crate::{AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, Finalize};
+use crate::{AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingError, Finalize};
-use crate::{BindingError, HasGenericParams, MacroRulesScope, Module, ModuleOrUniformRoot};
+use crate::{HasGenericParams, MacroRulesScope, Module, ModuleKind, ModuleOrUniformRoot};
 use crate::{LexicalScopeBinding, NameBinding, NameBindingKind, PrivacyError, VisResolutionError};
-use crate::{ParentScope, PathResult, ResolutionError, Resolver, Scope, ScopeSet, Segment};
+use crate::{ParentScope, PathResult, ResolutionError, Resolver, Scope, ScopeSet};
+use crate::{Segment, UseError};
 
 type Res = def::Res<ast::NodeId>;
 
@@ -84,6 +89,390 @@ fn reduce_impl_span_to_impl_keyword(sm: &SourceMap, impl_span: Span) -> Span {
 }
 
 impl<'a> Resolver<'a> {
+    crate fn report_errors(&mut self, krate: &Crate) {
+        self.report_with_use_injections(krate);
+
+        for &(span_use, span_def) in &self.macro_expanded_macro_export_errors {
+            let msg = "macro-expanded `macro_export` macros from the current crate \
+                       cannot be referred to by absolute paths";
+            self.lint_buffer.buffer_lint_with_diagnostic(
+                MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
+                CRATE_NODE_ID,
+                span_use,
+                msg,
+                BuiltinLintDiagnostics::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def),
+            );
+        }
+
+        for ambiguity_error in &self.ambiguity_errors {
+            self.report_ambiguity_error(ambiguity_error);
+        }
+
+        let mut reported_spans = FxHashSet::default();
+        for error in &self.privacy_errors {
+            if reported_spans.insert(error.dedup_span) {
+                self.report_privacy_error(error);
+            }
+        }
+    }
+
+    fn report_with_use_injections(&mut self, krate: &Crate) {
+        for UseError { mut err, candidates, def_id, instead, suggestion } in
+            self.use_injections.drain(..)
+        {
+            let (span, found_use) = if let Some(def_id) = def_id.as_local() {
+                UsePlacementFinder::check(krate, self.def_id_to_node_id[def_id])
+            } else {
+                (None, false)
+            };
+            if !candidates.is_empty() {
+                show_candidates(
+                    &self.definitions,
+                    self.session,
+                    &mut err,
+                    span,
+                    &candidates,
+                    instead,
+                    found_use,
+                );
+            } else if let Some((span, msg, sugg, appl)) = suggestion {
+                err.span_suggestion(span, msg, sugg, appl);
+            }
+            err.emit();
+        }
+    }
+
+    crate fn report_conflict<'b>(
+        &mut self,
+        parent: Module<'_>,
+        ident: Ident,
+        ns: Namespace,
+        new_binding: &NameBinding<'b>,
+        old_binding: &NameBinding<'b>,
+    ) {
+        // Error on the second of two conflicting names
+        if old_binding.span.lo() > new_binding.span.lo() {
+            return self.report_conflict(parent, ident, ns, old_binding, new_binding);
+        }
+
+        let container = match parent.kind {
+            ModuleKind::Def(kind, _, _) => kind.descr(parent.def_id()),
+            ModuleKind::Block(..) => "block",
+        };
+
+        let old_noun = match old_binding.is_import() {
+            true => "import",
+            false => "definition",
+        };
+
+        let new_participle = match new_binding.is_import() {
+            true => "imported",
+            false => "defined",
+        };
+
+        let (name, span) =
+            (ident.name, self.session.source_map().guess_head_span(new_binding.span));
+
+        if let Some(s) = self.name_already_seen.get(&name) {
+            if s == &span {
+                return;
+            }
+        }
+
+        let old_kind = match (ns, old_binding.module()) {
+            (ValueNS, _) => "value",
+            (MacroNS, _) => "macro",
+            (TypeNS, _) if old_binding.is_extern_crate() => "extern crate",
+            (TypeNS, Some(module)) if module.is_normal() => "module",
+            (TypeNS, Some(module)) if module.is_trait() => "trait",
+            (TypeNS, _) => "type",
+        };
+
+        let msg = format!("the name `{}` is defined multiple times", name);
+
+        let mut err = match (old_binding.is_extern_crate(), new_binding.is_extern_crate()) {
+            (true, true) => struct_span_err!(self.session, span, E0259, "{}", msg),
+            (true, _) | (_, true) => match new_binding.is_import() && old_binding.is_import() {
+                true => struct_span_err!(self.session, span, E0254, "{}", msg),
+                false => struct_span_err!(self.session, span, E0260, "{}", msg),
+            },
+            _ => match (old_binding.is_import(), new_binding.is_import()) {
+                (false, false) => struct_span_err!(self.session, span, E0428, "{}", msg),
+                (true, true) => struct_span_err!(self.session, span, E0252, "{}", msg),
+                _ => struct_span_err!(self.session, span, E0255, "{}", msg),
+            },
+        };
+
+        err.note(&format!(
+            "`{}` must be defined only once in the {} namespace of this {}",
+            name,
+            ns.descr(),
+            container
+        ));
+
+        err.span_label(span, format!("`{}` re{} here", name, new_participle));
+        err.span_label(
+            self.session.source_map().guess_head_span(old_binding.span),
+            format!("previous {} of the {} `{}` here", old_noun, old_kind, name),
+        );
+
+        // See https://github.com/rust-lang/rust/issues/32354
+        use NameBindingKind::Import;
+        let import = match (&new_binding.kind, &old_binding.kind) {
+            // If there are two imports where one or both have attributes then prefer removing the
+            // import without attributes.
+            (Import { import: new, .. }, Import { import: old, .. })
+                if {
+                    !new_binding.span.is_dummy()
+                        && !old_binding.span.is_dummy()
+                        && (new.has_attributes || old.has_attributes)
+                } =>
+            {
+                if old.has_attributes {
+                    Some((new, new_binding.span, true))
+                } else {
+                    Some((old, old_binding.span, true))
+                }
+            }
+            // Otherwise prioritize the new binding.
+            (Import { import, .. }, other) if !new_binding.span.is_dummy() => {
+                Some((import, new_binding.span, other.is_import()))
+            }
+            (other, Import { import, .. }) if !old_binding.span.is_dummy() => {
+                Some((import, old_binding.span, other.is_import()))
+            }
+            _ => None,
+        };
+
+        // Check if the target of the use for both bindings is the same.
+        let duplicate = new_binding.res().opt_def_id() == old_binding.res().opt_def_id();
+        let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy();
+        let from_item =
+            self.extern_prelude.get(&ident).map_or(true, |entry| entry.introduced_by_item);
+        // Only suggest removing an import if both bindings are to the same def, if both spans
+        // aren't dummy spans. Further, if both bindings are imports, then the ident must have
+        // been introduced by an item.
+        let should_remove_import = duplicate
+            && !has_dummy_span
+            && ((new_binding.is_extern_crate() || old_binding.is_extern_crate()) || from_item);
+
+        match import {
+            Some((import, span, true)) if should_remove_import && import.is_nested() => {
+                self.add_suggestion_for_duplicate_nested_use(&mut err, import, span)
+            }
+            Some((import, _, true)) if should_remove_import && !import.is_glob() => {
+                // Simple case - remove the entire import. Due to the above match arm, this can
+                // only be a single use so just remove it entirely.
+                err.tool_only_span_suggestion(
+                    import.use_span_with_attributes,
+                    "remove unnecessary import",
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+            Some((import, span, _)) => {
+                self.add_suggestion_for_rename_of_use(&mut err, name, import, span)
+            }
+            _ => {}
+        }
+
+        err.emit();
+        self.name_already_seen.insert(name, span);
+    }
+
+    /// This function adds a suggestion to change the binding name of a new import that conflicts
+    /// with an existing import.
+    ///
+    /// ```text,ignore (diagnostic)
+    /// help: you can use `as` to change the binding name of the import
+    ///    |
+    /// LL | use foo::bar as other_bar;
+    ///    |     ^^^^^^^^^^^^^^^^^^^^^
+    /// ```
+    fn add_suggestion_for_rename_of_use(
+        &self,
+        err: &mut Diagnostic,
+        name: Symbol,
+        import: &Import<'_>,
+        binding_span: Span,
+    ) {
+        let suggested_name = if name.as_str().chars().next().unwrap().is_uppercase() {
+            format!("Other{}", name)
+        } else {
+            format!("other_{}", name)
+        };
+
+        let mut suggestion = None;
+        match import.kind {
+            ImportKind::Single { type_ns_only: true, .. } => {
+                suggestion = Some(format!("self as {}", suggested_name))
+            }
+            ImportKind::Single { source, .. } => {
+                if let Some(pos) =
+                    source.span.hi().0.checked_sub(binding_span.lo().0).map(|pos| pos as usize)
+                {
+                    if let Ok(snippet) = self.session.source_map().span_to_snippet(binding_span) {
+                        if pos <= snippet.len() {
+                            suggestion = Some(format!(
+                                "{} as {}{}",
+                                &snippet[..pos],
+                                suggested_name,
+                                if snippet.ends_with(';') { ";" } else { "" }
+                            ))
+                        }
+                    }
+                }
+            }
+            ImportKind::ExternCrate { source, target } => {
+                suggestion = Some(format!(
+                    "extern crate {} as {};",
+                    source.unwrap_or(target.name),
+                    suggested_name,
+                ))
+            }
+            _ => unreachable!(),
+        }
+
+        let rename_msg = "you can use `as` to change the binding name of the import";
+        if let Some(suggestion) = suggestion {
+            err.span_suggestion(
+                binding_span,
+                rename_msg,
+                suggestion,
+                Applicability::MaybeIncorrect,
+            );
+        } else {
+            err.span_label(binding_span, rename_msg);
+        }
+    }
+
+    /// This function adds a suggestion to remove an unnecessary binding from an import that is
+    /// nested. In the following example, this function will be invoked to remove the `a` binding
+    /// in the second use statement:
+    ///
+    /// ```ignore (diagnostic)
+    /// use issue_52891::a;
+    /// use issue_52891::{d, a, e};
+    /// ```
+    ///
+    /// The following suggestion will be added:
+    ///
+    /// ```ignore (diagnostic)
+    /// use issue_52891::{d, a, e};
+    ///                      ^-- help: remove unnecessary import
+    /// ```
+    ///
+    /// If the nested use contains only one import then the suggestion will remove the entire
+    /// line.
+    ///
+    /// It is expected that the provided import is nested - this isn't checked by the
+    /// function. If this invariant is not upheld, this function's behaviour will be unexpected
+    /// as characters expected by span manipulations won't be present.
+    fn add_suggestion_for_duplicate_nested_use(
+        &self,
+        err: &mut Diagnostic,
+        import: &Import<'_>,
+        binding_span: Span,
+    ) {
+        assert!(import.is_nested());
+        let message = "remove unnecessary import";
+
+        // Two examples will be used to illustrate the span manipulations we're doing:
+        //
+        // - Given `use issue_52891::{d, a, e};` where `a` is a duplicate then `binding_span` is
+        //   `a` and `import.use_span` is `issue_52891::{d, a, e};`.
+        // - Given `use issue_52891::{d, e, a};` where `a` is a duplicate then `binding_span` is
+        //   `a` and `import.use_span` is `issue_52891::{d, e, a};`.
+
+        let (found_closing_brace, span) =
+            find_span_of_binding_until_next_binding(self.session, binding_span, import.use_span);
+
+        // If there was a closing brace then identify the span to remove any trailing commas from
+        // previous imports.
+        if found_closing_brace {
+            if let Some(span) = extend_span_to_previous_binding(self.session, span) {
+                err.tool_only_span_suggestion(
+                    span,
+                    message,
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                // Remove the entire line if we cannot extend the span back, this indicates an
+                // `issue_52891::{self}` case.
+                err.span_suggestion(
+                    import.use_span_with_attributes,
+                    message,
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+
+            return;
+        }
+
+        err.span_suggestion(span, message, String::new(), Applicability::MachineApplicable);
+    }
+
+    crate fn lint_if_path_starts_with_module(
+        &mut self,
+        finalize: Finalize,
+        path: &[Segment],
+        second_binding: Option<&NameBinding<'_>>,
+    ) {
+        let (diag_id, diag_span) = match finalize {
+            Finalize::No => return,
+            Finalize::SimplePath(id, path_span) => (id, path_span),
+            Finalize::UsePath { root_id, root_span, .. } => (root_id, root_span),
+            Finalize::QPathTrait { qpath_id, qpath_span, .. } => (qpath_id, qpath_span),
+        };
+
+        let first_name = match path.get(0) {
+            // In the 2018 edition this lint is a hard error, so nothing to do
+            Some(seg) if seg.ident.span.rust_2015() && self.session.rust_2015() => seg.ident.name,
+            _ => return,
+        };
+
+        // We're only interested in `use` paths which should start with
+        // `{{root}}` currently.
+        if first_name != kw::PathRoot {
+            return;
+        }
+
+        match path.get(1) {
+            // If this import looks like `crate::...` it's already good
+            Some(Segment { ident, .. }) if ident.name == kw::Crate => return,
+            // Otherwise go below to see if it's an extern crate
+            Some(_) => {}
+            // If the path has length one (and it's `PathRoot` most likely)
+            // then we don't know whether we're gonna be importing a crate or an
+            // item in our crate. Defer this lint to elsewhere
+            None => return,
+        }
+
+        // If the first element of our path was actually resolved to an
+        // `ExternCrate` (also used for `crate::...`) then no need to issue a
+        // warning, this looks all good!
+        if let Some(binding) = second_binding {
+            if let NameBindingKind::Import { import, .. } = binding.kind {
+                // Careful: we still want to rewrite paths from renamed extern crates.
+                if let ImportKind::ExternCrate { source: None, .. } = import.kind {
+                    return;
+                }
+            }
+        }
+
+        let diag = BuiltinLintDiagnostics::AbsPathWithModule(diag_span);
+        self.lint_buffer.buffer_lint_with_diagnostic(
+            ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
+            diag_id,
+            diag_span,
+            "absolute paths must start with `self`, `super`, \
+             `crate`, or an external crate name in the 2018 edition",
+            diag,
+        );
+    }
+
     crate fn add_module_candidates(
         &mut self,
         module: Module<'a>,
@@ -1227,7 +1616,7 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    crate fn report_ambiguity_error(&self, ambiguity_error: &AmbiguityError<'_>) {
+    fn report_ambiguity_error(&self, ambiguity_error: &AmbiguityError<'_>) {
         let AmbiguityError { kind, ident, b1, b2, misc1, misc2 } = *ambiguity_error;
         let (b1, b2, misc1, misc2, swapped) = if b2.span.is_dummy() && !b1.span.is_dummy() {
             // We have to print the span-less alternative first, otherwise formatting looks bad.
@@ -1293,7 +1682,7 @@ impl<'a> Resolver<'a> {
         None
     }
 
-    crate fn report_privacy_error(&self, privacy_error: &PrivacyError<'_>) {
+    fn report_privacy_error(&self, privacy_error: &PrivacyError<'_>) {
         let PrivacyError { ident, binding, .. } = *privacy_error;
 
         let res = binding.res();
@@ -1859,7 +2248,7 @@ impl<'a, 'b> ImportResolver<'a, 'b> {
 /// use foo::{a, b, c};
 ///              ^^^
 /// ```
-pub(crate) fn find_span_of_binding_until_next_binding(
+fn find_span_of_binding_until_next_binding(
     sess: &Session,
     binding_span: Span,
     use_span: Span,
@@ -1910,7 +2299,7 @@ pub(crate) fn find_span_of_binding_until_next_binding(
 /// use foo::{a, b, c};
 ///           --- binding span
 /// ```
-pub(crate) fn extend_span_to_previous_binding(sess: &Session, binding_span: Span) -> Option<Span> {
+fn extend_span_to_previous_binding(sess: &Session, binding_span: Span) -> Option<Span> {
     let source_map = sess.source_map();
 
     // `prev_source` will contain all of the source that came before the span.
@@ -1998,7 +2387,7 @@ fn find_span_immediately_after_crate_name(
 /// When an entity with a given name is not available in scope, we search for
 /// entities with that name in all crates. This method allows outputting the
 /// results of this search in a programmer-friendly way
-crate fn show_candidates(
+fn show_candidates(
     definitions: &rustc_hir::definitions::Definitions,
     session: &Session,
     err: &mut Diagnostic,
@@ -2133,3 +2522,70 @@ crate fn show_candidates(
         }
     }
 }
+
+#[derive(Debug)]
+struct UsePlacementFinder {
+    target_module: NodeId,
+    first_legal_span: Option<Span>,
+    first_use_span: Option<Span>,
+}
+
+impl UsePlacementFinder {
+    fn check(krate: &Crate, target_module: NodeId) -> (Option<Span>, bool) {
+        let mut finder =
+            UsePlacementFinder { target_module, first_legal_span: None, first_use_span: None };
+        finder.visit_crate(krate);
+        if let Some(use_span) = finder.first_use_span {
+            (Some(use_span), true)
+        } else {
+            (finder.first_legal_span, false)
+        }
+    }
+}
+
+impl<'tcx> visit::Visitor<'tcx> for UsePlacementFinder {
+    fn visit_crate(&mut self, c: &Crate) {
+        if self.target_module == CRATE_NODE_ID {
+            let inject = c.spans.inject_use_span;
+            if is_span_suitable_for_use_injection(inject) {
+                self.first_legal_span = Some(inject);
+            }
+            self.first_use_span = search_for_any_use_in_items(&c.items);
+            return;
+        } else {
+            visit::walk_crate(self, c);
+        }
+    }
+
+    fn visit_item(&mut self, item: &'tcx ast::Item) {
+        if self.target_module == item.id {
+            if let ItemKind::Mod(_, ModKind::Loaded(items, _inline, mod_spans)) = &item.kind {
+                let inject = mod_spans.inject_use_span;
+                if is_span_suitable_for_use_injection(inject) {
+                    self.first_legal_span = Some(inject);
+                }
+                self.first_use_span = search_for_any_use_in_items(items);
+                return;
+            }
+        } else {
+            visit::walk_item(self, item);
+        }
+    }
+}
+
+fn search_for_any_use_in_items(items: &[P<ast::Item>]) -> Option<Span> {
+    for item in items {
+        if let ItemKind::Use(..) = item.kind {
+            if is_span_suitable_for_use_injection(item.span) {
+                return Some(item.span.shrink_to_lo());
+            }
+        }
+    }
+    return None;
+}
+
+fn is_span_suitable_for_use_injection(s: Span) -> bool {
+    // don't suggest placing a use before the prelude
+    // import or other generated ones
+    !s.from_expansion()
+}

compiler/rustc_resolve/src/lib.rs

@@ -1,5 +1,3 @@
-// ignore-tidy-filelength
-
 //! This crate is responsible for the part of name resolution that doesn't require type checker.
 //!
 //! Module structure of the crate is built here.
@@ -28,19 +26,13 @@ pub use rustc_hir::def::{Namespace, PerNS};
 
 use rustc_arena::{DroplessArena, TypedArena};
 use rustc_ast::node_id::NodeMap;
-use rustc_ast::ptr::P;
+use rustc_ast::{self as ast, NodeId, CRATE_NODE_ID};
-use rustc_ast::visit::{self, Visitor};
+use rustc_ast::{Crate, Expr, ExprKind, LitKind, Path};
-use rustc_ast::{self as ast, NodeId};
-use rustc_ast::{Crate, CRATE_NODE_ID};
-use rustc_ast::{Expr, ExprKind, LitKind};
-use rustc_ast::{ItemKind, ModKind, Path};
 use rustc_ast_lowering::ResolverAstLowering;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::sync::Lrc;
-use rustc_errors::{
+use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed};
-    struct_span_err, Applicability, Diagnostic, DiagnosticBuilder, ErrorGuaranteed,
-};
 use rustc_expand::base::{DeriveResolutions, SyntaxExtension, SyntaxExtensionKind};
 use rustc_hir::def::Namespace::*;
 use rustc_hir::def::{self, CtorOf, DefKind, PartialRes};
@@ -57,8 +49,7 @@ use rustc_middle::ty::query::Providers;
 use rustc_middle::ty::{self, DefIdTree, MainDefinition, RegisteredTools, ResolverOutputs};
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::cstore::{CrateStore, MetadataLoaderDyn};
-use rustc_session::lint;
+use rustc_session::lint::LintBuffer;
-use rustc_session::lint::{BuiltinLintDiagnostics, LintBuffer};
 use rustc_session::Session;
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency};
 use rustc_span::source_map::Spanned;
@@ -71,7 +62,6 @@ use std::collections::BTreeSet;
 use std::{cmp, fmt, mem, ptr};
 use tracing::debug;
 
-use diagnostics::{extend_span_to_previous_binding, find_span_of_binding_until_next_binding};
 use diagnostics::{ImportSuggestion, LabelSuggestion, Suggestion};
 use imports::{Import, ImportKind, ImportResolver, NameResolution};
 use late::{HasGenericParams, PathSource};
@@ -312,73 +302,6 @@ impl<'a> From<&'a ast::PathSegment> for Segment {
     }
 }
 
-#[derive(Debug)]
-struct UsePlacementFinder {
-    target_module: NodeId,
-    first_legal_span: Option<Span>,
-    first_use_span: Option<Span>,
-}
-
-impl UsePlacementFinder {
-    fn check(krate: &Crate, target_module: NodeId) -> (Option<Span>, bool) {
-        let mut finder =
-            UsePlacementFinder { target_module, first_legal_span: None, first_use_span: None };
-        finder.visit_crate(krate);
-        if let Some(use_span) = finder.first_use_span {
-            (Some(use_span), true)
-        } else {
-            (finder.first_legal_span, false)
-        }
-    }
-}
-
-fn is_span_suitable_for_use_injection(s: Span) -> bool {
-    // don't suggest placing a use before the prelude
-    // import or other generated ones
-    !s.from_expansion()
-}
-
-fn search_for_any_use_in_items(items: &[P<ast::Item>]) -> Option<Span> {
-    for item in items {
-        if let ItemKind::Use(..) = item.kind {
-            if is_span_suitable_for_use_injection(item.span) {
-                return Some(item.span.shrink_to_lo());
-            }
-        }
-    }
-    return None;
-}
-
-impl<'tcx> Visitor<'tcx> for UsePlacementFinder {
-    fn visit_crate(&mut self, c: &Crate) {
-        if self.target_module == CRATE_NODE_ID {
-            let inject = c.spans.inject_use_span;
-            if is_span_suitable_for_use_injection(inject) {
-                self.first_legal_span = Some(inject);
-            }
-            self.first_use_span = search_for_any_use_in_items(&c.items);
-            return;
-        } else {
-            visit::walk_crate(self, c);
-        }
-    }
-
-    fn visit_item(&mut self, item: &'tcx ast::Item) {
-        if self.target_module == item.id {
-            if let ItemKind::Mod(_, ModKind::Loaded(items, _inline, mod_spans)) = &item.kind {
-                let inject = mod_spans.inject_use_span;
-                if is_span_suitable_for_use_injection(inject) {
-                    self.first_legal_span = Some(inject);
-                }
-                self.first_use_span = search_for_any_use_in_items(items);
-                return;
-            }
-        } else {
-            visit::walk_item(self, item);
-        }
-    }
-}
-
 /// An intermediate resolution result.
 ///
 /// This refers to the thing referred by a name. The difference between `Res` and `Item` is that
@@ -1800,65 +1723,6 @@ impl<'a> Resolver<'a> {
         module
     }
 
-    fn lint_if_path_starts_with_module(
-        &mut self,
-        finalize: Finalize,
-        path: &[Segment],
-        second_binding: Option<&NameBinding<'_>>,
-    ) {
-        let (diag_id, diag_span) = match finalize {
-            Finalize::No => return,
-            Finalize::SimplePath(id, path_span) => (id, path_span),
-            Finalize::UsePath { root_id, root_span, .. } => (root_id, root_span),
-            Finalize::QPathTrait { qpath_id, qpath_span, .. } => (qpath_id, qpath_span),
-        };
-
-        let first_name = match path.get(0) {
-            // In the 2018 edition this lint is a hard error, so nothing to do
-            Some(seg) if seg.ident.span.rust_2015() && self.session.rust_2015() => seg.ident.name,
-            _ => return,
-        };
-
-        // We're only interested in `use` paths which should start with
-        // `{{root}}` currently.
-        if first_name != kw::PathRoot {
-            return;
-        }
-
-        match path.get(1) {
-            // If this import looks like `crate::...` it's already good
-            Some(Segment { ident, .. }) if ident.name == kw::Crate => return,
-            // Otherwise go below to see if it's an extern crate
-            Some(_) => {}
-            // If the path has length one (and it's `PathRoot` most likely)
-            // then we don't know whether we're gonna be importing a crate or an
-            // item in our crate. Defer this lint to elsewhere
-            None => return,
-        }
-
-        // If the first element of our path was actually resolved to an
-        // `ExternCrate` (also used for `crate::...`) then no need to issue a
-        // warning, this looks all good!
-        if let Some(binding) = second_binding {
-            if let NameBindingKind::Import { import, .. } = binding.kind {
-                // Careful: we still want to rewrite paths from renamed extern crates.
-                if let ImportKind::ExternCrate { source: None, .. } = import.kind {
-                    return;
-                }
-            }
-        }
-
-        let diag = BuiltinLintDiagnostics::AbsPathWithModule(diag_span);
-        self.lint_buffer.buffer_lint_with_diagnostic(
-            lint::builtin::ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
-            diag_id,
-            diag_span,
-            "absolute paths must start with `self`, `super`, \
-             `crate`, or an external crate name in the 2018 edition",
-            diag,
-        );
-    }
-
     fn record_partial_res(&mut self, node_id: NodeId, resolution: PartialRes) {
         debug!("(recording res) recording {:?} for {}", resolution, node_id);
         if let Some(prev_res) = self.partial_res_map.insert(node_id, resolution) {
@@ -1905,331 +1769,6 @@ impl<'a> Resolver<'a> {
         }
     }
 
-    fn report_errors(&mut self, krate: &Crate) {
-        self.report_with_use_injections(krate);
-
-        for &(span_use, span_def) in &self.macro_expanded_macro_export_errors {
-            let msg = "macro-expanded `macro_export` macros from the current crate \
-                       cannot be referred to by absolute paths";
-            self.lint_buffer.buffer_lint_with_diagnostic(
-                lint::builtin::MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
-                CRATE_NODE_ID,
-                span_use,
-                msg,
-                BuiltinLintDiagnostics::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def),
-            );
-        }
-
-        for ambiguity_error in &self.ambiguity_errors {
-            self.report_ambiguity_error(ambiguity_error);
-        }
-
-        let mut reported_spans = FxHashSet::default();
-        for error in &self.privacy_errors {
-            if reported_spans.insert(error.dedup_span) {
-                self.report_privacy_error(error);
-            }
-        }
-    }
-
-    fn report_with_use_injections(&mut self, krate: &Crate) {
-        for UseError { mut err, candidates, def_id, instead, suggestion } in
-            self.use_injections.drain(..)
-        {
-            let (span, found_use) = if let Some(def_id) = def_id.as_local() {
-                UsePlacementFinder::check(krate, self.def_id_to_node_id[def_id])
-            } else {
-                (None, false)
-            };
-            if !candidates.is_empty() {
-                diagnostics::show_candidates(
-                    &self.definitions,
-                    self.session,
-                    &mut err,
-                    span,
-                    &candidates,
-                    instead,
-                    found_use,
-                );
-            } else if let Some((span, msg, sugg, appl)) = suggestion {
-                err.span_suggestion(span, msg, sugg, appl);
-            }
-            err.emit();
-        }
-    }
-
-    fn report_conflict<'b>(
-        &mut self,
-        parent: Module<'_>,
-        ident: Ident,
-        ns: Namespace,
-        new_binding: &NameBinding<'b>,
-        old_binding: &NameBinding<'b>,
-    ) {
-        // Error on the second of two conflicting names
-        if old_binding.span.lo() > new_binding.span.lo() {
-            return self.report_conflict(parent, ident, ns, old_binding, new_binding);
-        }
-
-        let container = match parent.kind {
-            ModuleKind::Def(kind, _, _) => kind.descr(parent.def_id()),
-            ModuleKind::Block(..) => "block",
-        };
-
-        let old_noun = match old_binding.is_import() {
-            true => "import",
-            false => "definition",
-        };
-
-        let new_participle = match new_binding.is_import() {
-            true => "imported",
-            false => "defined",
-        };
-
-        let (name, span) =
-            (ident.name, self.session.source_map().guess_head_span(new_binding.span));
-
-        if let Some(s) = self.name_already_seen.get(&name) {
-            if s == &span {
-                return;
-            }
-        }
-
-        let old_kind = match (ns, old_binding.module()) {
-            (ValueNS, _) => "value",
-            (MacroNS, _) => "macro",
-            (TypeNS, _) if old_binding.is_extern_crate() => "extern crate",
-            (TypeNS, Some(module)) if module.is_normal() => "module",
-            (TypeNS, Some(module)) if module.is_trait() => "trait",
-            (TypeNS, _) => "type",
-        };
-
-        let msg = format!("the name `{}` is defined multiple times", name);
-
-        let mut err = match (old_binding.is_extern_crate(), new_binding.is_extern_crate()) {
-            (true, true) => struct_span_err!(self.session, span, E0259, "{}", msg),
-            (true, _) | (_, true) => match new_binding.is_import() && old_binding.is_import() {
-                true => struct_span_err!(self.session, span, E0254, "{}", msg),
-                false => struct_span_err!(self.session, span, E0260, "{}", msg),
-            },
-            _ => match (old_binding.is_import(), new_binding.is_import()) {
-                (false, false) => struct_span_err!(self.session, span, E0428, "{}", msg),
-                (true, true) => struct_span_err!(self.session, span, E0252, "{}", msg),
-                _ => struct_span_err!(self.session, span, E0255, "{}", msg),
-            },
-        };
-
-        err.note(&format!(
-            "`{}` must be defined only once in the {} namespace of this {}",
-            name,
-            ns.descr(),
-            container
-        ));
-
-        err.span_label(span, format!("`{}` re{} here", name, new_participle));
-        err.span_label(
-            self.session.source_map().guess_head_span(old_binding.span),
-            format!("previous {} of the {} `{}` here", old_noun, old_kind, name),
-        );
-
-        // See https://github.com/rust-lang/rust/issues/32354
-        use NameBindingKind::Import;
-        let import = match (&new_binding.kind, &old_binding.kind) {
-            // If there are two imports where one or both have attributes then prefer removing the
-            // import without attributes.
-            (Import { import: new, .. }, Import { import: old, .. })
-                if {
-                    !new_binding.span.is_dummy()
-                        && !old_binding.span.is_dummy()
-                        && (new.has_attributes || old.has_attributes)
-                } =>
-            {
-                if old.has_attributes {
-                    Some((new, new_binding.span, true))
-                } else {
-                    Some((old, old_binding.span, true))
-                }
-            }
-            // Otherwise prioritize the new binding.
-            (Import { import, .. }, other) if !new_binding.span.is_dummy() => {
-                Some((import, new_binding.span, other.is_import()))
-            }
-            (other, Import { import, .. }) if !old_binding.span.is_dummy() => {
-                Some((import, old_binding.span, other.is_import()))
-            }
-            _ => None,
-        };
-
-        // Check if the target of the use for both bindings is the same.
-        let duplicate = new_binding.res().opt_def_id() == old_binding.res().opt_def_id();
-        let has_dummy_span = new_binding.span.is_dummy() || old_binding.span.is_dummy();
-        let from_item =
-            self.extern_prelude.get(&ident).map_or(true, |entry| entry.introduced_by_item);
-        // Only suggest removing an import if both bindings are to the same def, if both spans
-        // aren't dummy spans. Further, if both bindings are imports, then the ident must have
-        // been introduced by an item.
-        let should_remove_import = duplicate
-            && !has_dummy_span
-            && ((new_binding.is_extern_crate() || old_binding.is_extern_crate()) || from_item);
-
-        match import {
-            Some((import, span, true)) if should_remove_import && import.is_nested() => {
-                self.add_suggestion_for_duplicate_nested_use(&mut err, import, span)
-            }
-            Some((import, _, true)) if should_remove_import && !import.is_glob() => {
-                // Simple case - remove the entire import. Due to the above match arm, this can
-                // only be a single use so just remove it entirely.
-                err.tool_only_span_suggestion(
-                    import.use_span_with_attributes,
-                    "remove unnecessary import",
-                    String::new(),
-                    Applicability::MaybeIncorrect,
-                );
-            }
-            Some((import, span, _)) => {
-                self.add_suggestion_for_rename_of_use(&mut err, name, import, span)
-            }
-            _ => {}
-        }
-
-        err.emit();
-        self.name_already_seen.insert(name, span);
-    }
-
-    /// This function adds a suggestion to change the binding name of a new import that conflicts
-    /// with an existing import.
-    ///
-    /// ```text,ignore (diagnostic)
-    /// help: you can use `as` to change the binding name of the import
-    ///    |
-    /// LL | use foo::bar as other_bar;
-    ///    |     ^^^^^^^^^^^^^^^^^^^^^
-    /// ```
-    fn add_suggestion_for_rename_of_use(
-        &self,
-        err: &mut Diagnostic,
-        name: Symbol,
-        import: &Import<'_>,
-        binding_span: Span,
-    ) {
-        let suggested_name = if name.as_str().chars().next().unwrap().is_uppercase() {
-            format!("Other{}", name)
-        } else {
-            format!("other_{}", name)
-        };
-
-        let mut suggestion = None;
-        match import.kind {
-            ImportKind::Single { type_ns_only: true, .. } => {
-                suggestion = Some(format!("self as {}", suggested_name))
-            }
-            ImportKind::Single { source, .. } => {
-                if let Some(pos) =
-                    source.span.hi().0.checked_sub(binding_span.lo().0).map(|pos| pos as usize)
-                {
-                    if let Ok(snippet) = self.session.source_map().span_to_snippet(binding_span) {
-                        if pos <= snippet.len() {
-                            suggestion = Some(format!(
-                                "{} as {}{}",
-                                &snippet[..pos],
-                                suggested_name,
-                                if snippet.ends_with(';') { ";" } else { "" }
-                            ))
-                        }
-                    }
-                }
-            }
-            ImportKind::ExternCrate { source, target } => {
-                suggestion = Some(format!(
-                    "extern crate {} as {};",
-                    source.unwrap_or(target.name),
-                    suggested_name,
-                ))
-            }
-            _ => unreachable!(),
-        }
-
-        let rename_msg = "you can use `as` to change the binding name of the import";
-        if let Some(suggestion) = suggestion {
-            err.span_suggestion(
-                binding_span,
-                rename_msg,
-                suggestion,
-                Applicability::MaybeIncorrect,
-            );
-        } else {
-            err.span_label(binding_span, rename_msg);
-        }
-    }
-
-    /// This function adds a suggestion to remove an unnecessary binding from an import that is
-    /// nested. In the following example, this function will be invoked to remove the `a` binding
-    /// in the second use statement:
-    ///
-    /// ```ignore (diagnostic)
-    /// use issue_52891::a;
-    /// use issue_52891::{d, a, e};
-    /// ```
-    ///
-    /// The following suggestion will be added:
-    ///
-    /// ```ignore (diagnostic)
-    /// use issue_52891::{d, a, e};
-    ///                      ^-- help: remove unnecessary import
-    /// ```
-    ///
-    /// If the nested use contains only one import then the suggestion will remove the entire
-    /// line.
-    ///
-    /// It is expected that the provided import is nested - this isn't checked by the
-    /// function. If this invariant is not upheld, this function's behaviour will be unexpected
-    /// as characters expected by span manipulations won't be present.
-    fn add_suggestion_for_duplicate_nested_use(
-        &self,
-        err: &mut Diagnostic,
-        import: &Import<'_>,
-        binding_span: Span,
-    ) {
-        assert!(import.is_nested());
-        let message = "remove unnecessary import";
-
-        // Two examples will be used to illustrate the span manipulations we're doing:
-        //
-        // - Given `use issue_52891::{d, a, e};` where `a` is a duplicate then `binding_span` is
-        //   `a` and `import.use_span` is `issue_52891::{d, a, e};`.
-        // - Given `use issue_52891::{d, e, a};` where `a` is a duplicate then `binding_span` is
-        //   `a` and `import.use_span` is `issue_52891::{d, e, a};`.
-
-        let (found_closing_brace, span) =
-            find_span_of_binding_until_next_binding(self.session, binding_span, import.use_span);
-
-        // If there was a closing brace then identify the span to remove any trailing commas from
-        // previous imports.
-        if found_closing_brace {
-            if let Some(span) = extend_span_to_previous_binding(self.session, span) {
-                err.tool_only_span_suggestion(
-                    span,
-                    message,
-                    String::new(),
-                    Applicability::MaybeIncorrect,
-                );
-            } else {
-                // Remove the entire line if we cannot extend the span back, this indicates an
-                // `issue_52891::{self}` case.
-                err.span_suggestion(
-                    import.use_span_with_attributes,
-                    message,
-                    String::new(),
-                    Applicability::MaybeIncorrect,
-                );
-            }
-
-            return;
-        }
-
-        err.span_suggestion(span, message, String::new(), Applicability::MachineApplicable);
-    }
-
     fn extern_prelude_get(&mut self, ident: Ident, finalize: bool) -> Option<&'a NameBinding<'a>> {
         if ident.is_path_segment_keyword() {
             // Make sure `self`, `super` etc produce an error when passed to here.