introduce, implement and use SmartResolver

Author: LorrensP-2158466

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -37,7 +37,7 @@ use crate::imports::{ImportData, ImportKind};
 use crate::macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 use crate::{
     BindingKey, ExternPreludeEntry, Finalize, MacroData, Module, ModuleKind, ModuleOrUniformRoot,
-    NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment, Used,
+    NameBinding, ParentScope, PathResult, ResolutionError, Resolver, Segment, SmartResolver, Used,
     VisResolutionError, errors,
 };
 
@@ -373,7 +373,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                         res,
                     ))
                 };
-                match self.r.resolve_path(
+                match SmartResolver::finalize(self.r, finalize).resolve_path(
                     &segments,
                     None,
                     parent_scope,

compiler/rustc_resolve/src/diagnostics.rs

@@ -45,8 +45,8 @@ use crate::{
     AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingError, BindingKey, Finalize,
     ForwardGenericParamBanReason, HasGenericParams, LexicalScopeBinding, MacroRulesScope, Module,
     ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult,
-    PrivacyError, ResolutionError, Resolver, Scope, ScopeSet, Segment, UseError, Used,
-    VisResolutionError, errors as errs, path_names_to_string,
+    PrivacyError, ResolutionError, Resolver, Scope, ScopeSet, Segment, SmartResolver, UseError,
+    Used, VisResolutionError, errors as errs, path_names_to_string,
 };
 
 type Res = def::Res<ast::NodeId>;
@@ -465,61 +465,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         err.subdiagnostic(errors::RemoveUnnecessaryImport { span });
     }
 
-    pub(crate) fn lint_if_path_starts_with_module(
-        &mut self,
-        finalize: Option<Finalize>,
-        path: &[Segment],
-        second_binding: Option<NameBinding<'_>>,
-    ) {
-        let Some(Finalize { node_id, root_span, .. }) = finalize else {
-            return;
-        };
-
-        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.is_rust_2015() && self.tcx.sess.is_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
-            && let NameBindingKind::Import { import, .. } = binding.kind
-            // Careful: we still want to rewrite paths from renamed extern crates.
-            && let ImportKind::ExternCrate { source: None, .. } = import.kind
-        {
-            return;
-        }
-
-        let diag = BuiltinLintDiag::AbsPathWithModule(root_span);
-        self.lint_buffer.buffer_lint(
-            ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
-            node_id,
-            root_span,
-            diag,
-        );
-    }
-
     pub(crate) fn add_module_candidates(
         &self,
         module: Module<'ra>,
@@ -1046,15 +991,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     if filter_fn(res) {
                         for derive in parent_scope.derives {
                             let parent_scope = &ParentScope { derives: &[], ..*parent_scope };
-                            let Ok((Some(ext), _)) = this.resolve_macro_path(
-                                derive,
-                                Some(MacroKind::Derive),
-                                parent_scope,
-                                false,
-                                false,
-                                None,
-                                None,
-                            ) else {
+                            let Ok((Some(ext), _)) = SmartResolver::Finalize(this)
+                                .resolve_macro_path(
+                                    derive,
+                                    Some(MacroKind::Derive),
+                                    parent_scope,
+                                    false,
+                                    false,
+                                    None,
+                                    None,
+                                )
+                            else {
                                 continue;
                             };
                             suggestions.extend(
@@ -1589,15 +1536,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             });
         }
         for ns in [Namespace::MacroNS, Namespace::TypeNS, Namespace::ValueNS] {
-            let Ok(binding) = self.early_resolve_ident_in_lexical_scope(
-                ident,
-                ScopeSet::All(ns),
-                parent_scope,
-                None,
-                false,
-                None,
-                None,
-            ) else {
+            let Ok(binding) = SmartResolver::Speculative(self)
+                .early_resolve_ident_in_lexical_scope(
+                    ident,
+                    ScopeSet::All(ns),
+                    parent_scope,
+                    None,
+                    false,
+                    None,
+                    None,
+                )
+            else {
                 continue;
             };
 
@@ -2269,21 +2218,22 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             if ns == TypeNS || ns == ValueNS {
                 let ns_to_try = if ns == TypeNS { ValueNS } else { TypeNS };
                 let binding = if let Some(module) = module {
-                    self.resolve_ident_in_module(
-                        module,
-                        ident,
-                        ns_to_try,
-                        parent_scope,
-                        None,
-                        ignore_binding,
-                        ignore_import,
-                    )
-                    .ok()
+                    SmartResolver::Speculative(self)
+                        .resolve_ident_in_module(
+                            module,
+                            ident,
+                            ns_to_try,
+                            parent_scope,
+                            None,
+                            ignore_binding,
+                            ignore_import,
+                        )
+                        .ok()
                 } else if let Some(ribs) = ribs
                     && let Some(TypeNS | ValueNS) = opt_ns
                 {
                     assert!(ignore_import.is_none());
-                    match self.resolve_ident_in_lexical_scope(
+                    match SmartResolver::Speculative(self).resolve_ident_in_lexical_scope(
                         ident,
                         ns_to_try,
                         parent_scope,
@@ -2296,16 +2246,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         _ => None,
                     }
                 } else {
-                    self.early_resolve_ident_in_lexical_scope(
-                        ident,
-                        ScopeSet::All(ns_to_try),
-                        parent_scope,
-                        None,
-                        false,
-                        ignore_binding,
-                        ignore_import,
-                    )
-                    .ok()
+                    SmartResolver::Speculative(self)
+                        .early_resolve_ident_in_lexical_scope(
+                            ident,
+                            ScopeSet::All(ns_to_try),
+                            parent_scope,
+                            None,
+                            false,
+                            ignore_binding,
+                            ignore_import,
+                        )
+                        .ok()
                 };
                 if let Some(binding) = binding {
                     msg = format!(
@@ -2332,7 +2283,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             // Check whether the name refers to an item in the value namespace.
             let binding = if let Some(ribs) = ribs {
                 assert!(ignore_import.is_none());
-                self.resolve_ident_in_lexical_scope(
+                SmartResolver::Speculative(self).resolve_ident_in_lexical_scope(
                     ident,
                     ValueNS,
                     parent_scope,
@@ -2399,15 +2350,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     },
                 )
             });
-            if let Ok(binding) = self.early_resolve_ident_in_lexical_scope(
-                ident,
-                ScopeSet::All(ValueNS),
-                parent_scope,
-                None,
-                false,
-                ignore_binding,
-                ignore_import,
-            ) {
+            if let Ok(binding) = SmartResolver::Speculative(self)
+                .early_resolve_ident_in_lexical_scope(
+                    ident,
+                    ScopeSet::All(ValueNS),
+                    parent_scope,
+                    None,
+                    false,
+                    ignore_binding,
+                    ignore_import,
+                )
+            {
                 let descr = binding.res().descr();
                 (format!("{descr} `{ident}` is not a crate or module"), suggestion)
             } else {
@@ -3297,6 +3250,63 @@ fn show_candidates(
     showed
 }
 
+impl<'r, 'ra, 'tcx> SmartResolver<'r, 'ra, 'tcx> {
+    pub(crate) fn lint_if_path_starts_with_module(
+        mut self,
+        finalize: Option<Finalize>,
+        path: &[Segment],
+        second_binding: Option<NameBinding<'_>>,
+    ) {
+        let Some(Finalize { node_id, root_span, .. }) = finalize else {
+            return;
+        };
+
+        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.is_rust_2015() && self.tcx.sess.is_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
+            && let NameBindingKind::Import { import, .. } = binding.kind
+            // Careful: we still want to rewrite paths from renamed extern crates.
+            && let ImportKind::ExternCrate { source: None, .. } = import.kind
+        {
+            return;
+        }
+
+        let diag = BuiltinLintDiag::AbsPathWithModule(root_span);
+        self.res_mut().lint_buffer.buffer_lint(
+            ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
+            node_id,
+            root_span,
+            diag,
+        );
+    }
+}
+
 #[derive(Debug)]
 struct UsePlacementFinder {
     target_module: NodeId,