resolve: Make sure macros and imports are resolved in full parent scope

Slightly simplify `fn build_reduced_graph_for_use_tree`

Author: petrochenkov

src/librustc_resolve/build_reduced_graph.rs

@@ -111,23 +111,23 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
 
     fn build_reduced_graph_for_use_tree(
         &mut self,
-        root_use_tree: &ast::UseTree,
-        root_id: NodeId,
+        // This particular use tree
         use_tree: &ast::UseTree,
         id: NodeId,
-        vis: ty::Visibility,
         parent_prefix: &[Ident],
-        mut uniform_paths_canary_emitted: bool,
         nested: bool,
-        item: &Item,
+        mut uniform_paths_canary_emitted: bool,
+        // The whole `use` item
         parent_scope: ParentScope<'a>,
+        item: &Item,
+        vis: ty::Visibility,
+        root_span: Span,
     ) {
         debug!("build_reduced_graph_for_use_tree(parent_prefix={:?}, \
                 uniform_paths_canary_emitted={}, \
                 use_tree={:?}, nested={})",
                parent_prefix, uniform_paths_canary_emitted, use_tree, nested);
 
-        let is_prelude = attr::contains_name(&item.attrs, "prelude_import");
         let uniform_paths =
             self.session.rust_2018() &&
             self.session.features_untracked().uniform_paths;
@@ -215,8 +215,8 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     subclass,
                     source.span,
                     id,
-                    root_use_tree.span,
-                    root_id,
+                    root_span,
+                    item.id,
                     ty::Visibility::Invisible,
                     parent_scope.clone(),
                     true, // is_uniform_paths_canary
@@ -339,25 +339,25 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     subclass,
                     use_tree.span,
                     id,
-                    root_use_tree.span,
-                    root_id,
+                    root_span,
+                    item.id,
                     vis,
                     parent_scope,
                     false, // is_uniform_paths_canary
                 );
             }
             ast::UseTreeKind::Glob => {
                 let subclass = GlobImport {
-                    is_prelude,
+                    is_prelude: attr::contains_name(&item.attrs, "prelude_import"),
                     max_vis: Cell::new(ty::Visibility::Invisible),
                 };
                 self.add_import_directive(
                     prefix,
                     subclass,
                     use_tree.span,
                     id,
-                    root_use_tree.span,
-                    root_id,
+                    root_span,
+                    item.id,
                     vis,
                     parent_scope,
                     false, // is_uniform_paths_canary
@@ -388,16 +388,10 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
 
                 for &(ref tree, id) in items {
                     self.build_reduced_graph_for_use_tree(
-                        root_use_tree,
-                        root_id,
-                        tree,
-                        id,
-                        vis,
-                        &prefix,
-                        uniform_paths_canary_emitted,
-                        true,
-                        item,
-                        parent_scope.clone(),
+                        // This particular use tree
+                        tree, id, &prefix, true, uniform_paths_canary_emitted,
+                        // The whole `use` item
+                        parent_scope.clone(), item, vis, root_span,
                     );
                 }
             }
@@ -415,16 +409,10 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         match item.node {
             ItemKind::Use(ref use_tree) => {
                 self.build_reduced_graph_for_use_tree(
-                    use_tree,
-                    item.id,
-                    use_tree,
-                    item.id,
-                    vis,
-                    &[],
-                    false, // uniform_paths_canary_emitted
-                    false,
-                    item,
-                    parent_scope,
+                    // This particular use tree
+                    use_tree, item.id, &[], false, false,
+                    // The whole `use` item
+                    parent_scope, item, vis, use_tree.span,
                 );
             }
 

src/librustc_resolve/error_reporting.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use {CrateLint, PathResult};
+use macros::ParentScope;
 
 use std::collections::BTreeSet;
 
@@ -24,6 +25,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
         &mut self,
         span: Span,
         path: Vec<Ident>
+        parent_scope: &ParentScope<'b>,
     ) -> Option<Vec<Ident>> {
         debug!("make_path_suggestion: span={:?} path={:?}", span, path);
         // If we don't have a path to suggest changes to, then return.
@@ -40,10 +42,12 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
             (Some(fst), Some(snd)) if !is_special(*fst) && !is_special(*snd) => {
                 debug!("make_path_suggestion: fst={:?} snd={:?}", fst, snd);
 
-                self.make_missing_self_suggestion(span, path.clone())
-                    .or_else(|| self.make_missing_crate_suggestion(span, path.clone()))
-                    .or_else(|| self.make_missing_super_suggestion(span, path.clone()))
-                    .or_else(|| self.make_external_crate_suggestion(span, path.clone()))
+                self.make_missing_self_suggestion(span, path.clone(), parent_scope)
+                    .or_else(|| self.make_missing_crate_suggestion(span, path.clone(),
+                                                                   parent_scope))
+                    .or_else(|| self.make_missing_super_suggestion(span, path.clone(),
+                                                                   parent_scope))
+                    .or_else(|| self.make_external_crate_suggestion(span, path, parent_scope))
             },
             _ => None,
         }
@@ -60,10 +64,11 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
         &mut self,
         span: Span,
         mut path: Vec<Ident>
+        parent_scope: &ParentScope<'b>,
     ) -> Option<Vec<Ident>> {
         // Replace first ident with `self` and check if that is valid.
         path[0].name = keywords::SelfValue.name();
-        let result = self.resolve_path(None, &path, None, false, span, CrateLint::No);
+        let result = self.resolve_path(None, &path, None, parent_scope, false, span, CrateLint::No);
         debug!("make_missing_self_suggestion: path={:?} result={:?}", path, result);
         if let PathResult::Module(..) = result {
             Some(path)
@@ -83,10 +88,11 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
         &mut self,
         span: Span,
         mut path: Vec<Ident>
+        parent_scope: &ParentScope<'b>,
     ) -> Option<Vec<Ident>> {
         // Replace first ident with `crate` and check if that is valid.
         path[0].name = keywords::Crate.name();
-        let result = self.resolve_path(None, &path, None, false, span, CrateLint::No);
+        let result = self.resolve_path(None, &path, None, parent_scope, false, span, CrateLint::No);
         debug!("make_missing_crate_suggestion:  path={:?} result={:?}", path, result);
         if let PathResult::Module(..) = result {
             Some(path)
@@ -106,10 +112,12 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
         &mut self,
         span: Span,
         mut path: Vec<Ident>
+        parent_scope: &ParentScope<'b>,
     ) -> Option<Vec<Ident>> {
         // Replace first ident with `crate` and check if that is valid.
         path[0].name = keywords::Super.name();
         let result = self.resolve_path(None, &path, None, false, span, CrateLint::No);
+        let result = self.resolve_path(None, &path, None, parent_scope, false, span, CrateLint::No);
         debug!("make_missing_super_suggestion:  path={:?} result={:?}", path, result);
         if let PathResult::Module(..) = result {
             Some(path)
@@ -132,6 +140,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
         &mut self,
         span: Span,
         mut path: Vec<Ident>
+        parent_scope: &ParentScope<'b>,
     ) -> Option<Vec<Ident>> {
         // Need to clone else we can't call `resolve_path` without a borrow error. We also store
         // into a `BTreeMap` so we can get consistent ordering (and therefore the same diagnostic)
@@ -149,7 +158,8 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
             // Replace the first after root (a placeholder we inserted) with a crate name
             // and check if that is valid.
             path[1].name = *name;
-            let result = self.resolve_path(None, &path, None, false, span, CrateLint::No);
+            let result =
+                self.resolve_path(None, &path, None, parent_scope, false, span, CrateLint::No);
             debug!("make_external_crate_suggestion: name={:?} path={:?} result={:?}",
                     name, path, result);
             if let PathResult::Module(..) = result {

src/librustc_resolve/lib.rs

@@ -1017,7 +1017,7 @@ pub struct ModuleData<'a> {
     resolutions: RefCell<FxHashMap<(Ident, Namespace), &'a RefCell<NameResolution<'a>>>>,
     legacy_macro_resolutions: RefCell<Vec<(Ident, MacroKind, ParentScope<'a>,
                                            Option<&'a NameBinding<'a>>)>>,
-    macro_resolutions: RefCell<Vec<(Box<[Ident]>, Span)>>,
+    macro_resolutions: RefCell<Vec<(Vec<Segment>, ParentScope<'a>, Span)>>,
     builtin_attrs: RefCell<Vec<(Ident, ParentScope<'a>)>>,
 
     // Macro invocations that can expand into items in this module.
@@ -1628,7 +1628,8 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
         let hir::Path { ref segments, span, ref mut def } = *path;
         let path: Vec<_> = segments.iter().map(|seg| seg.ident).collect();
         // FIXME (Manishearth): Intra doc links won't get warned of epoch changes
-        match self.resolve_path(None, &path, Some(namespace), true, span, CrateLint::No) {
+        match self.resolve_path_without_parent_scope(None, &path, Some(namespace), true, span,
+                                                     CrateLint::No) {
             PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                 *def = module.def().unwrap(),
             PathResult::NonModule(path_res) if path_res.unresolved_segments() == 0 =>
@@ -2472,10 +2473,10 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
                 new_id = Some(def.def_id());
                 let span = trait_ref.path.span;
                 if let PathResult::Module(ModuleOrUniformRoot::Module(module)) =
-                    self.resolve_path(
+                    self.resolve_path_without_parent_scope(
                         None,
                         &path,
-                        None,
+                        Some(TypeNS),
                         false,
                         span,
                         CrateLint::SimplePath(trait_ref.ref_id),
@@ -2993,8 +2994,9 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
                     (String::new(), "the crate root".to_string())
                 } else {
                     let mod_path = &path[..path.len() - 1];
-                    let mod_prefix = match this.resolve_path(None, mod_path, Some(TypeNS),
-                                                             false, span, CrateLint::No) {
+                    let mod_prefix = match this.resolve_path_without_parent_scope(
+                        None, mod_path, Some(TypeNS), false, span, CrateLint::No
+                    ) {
                         PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                             module.def(),
                         _ => None,
@@ -3478,7 +3480,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
             ));
         }
 
-        let result = match self.resolve_path(
+        let result = match self.resolve_path_without_parent_scope(
             None,
             &path,
             Some(ns),
@@ -3525,7 +3527,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
            path[0].name != keywords::CrateRoot.name() &&
            path[0].name != keywords::DollarCrate.name() {
             let unqualified_result = {
-                match self.resolve_path(
+                match self.resolve_path_without_parent_scope(
                     None,
                     &[*path.last().unwrap()],
                     Some(ns),
@@ -3548,7 +3550,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
         Some(result)
     }
 
-    fn resolve_path(
+    fn resolve_path_without_parent_scope(
         &mut self,
         base_module: Option<ModuleOrUniformRoot<'a>>,
         path: &[Ident],
@@ -3557,12 +3559,15 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
         path_span: Span,
         crate_lint: CrateLint,
     ) -> PathResult<'a> {
+        // Macro and import paths must have full parent scope available during resolution,
+        // other paths will do okay with parent module alone.
+        assert!(opt_ns != None && opt_ns != Some(MacroNS));
         let parent_scope = ParentScope { module: self.current_module, ..self.dummy_parent_scope() };
-        self.resolve_path_with_parent_scope(base_module, path, opt_ns, &parent_scope,
-                                            record_used, path_span, crate_lint)
+        self.resolve_path(base_module, path, opt_ns, &parent_scope,
+                          record_used, path_span, crate_lint)
     }
 
-    fn resolve_path_with_parent_scope(
+    fn resolve_path(
         &mut self,
         base_module: Option<ModuleOrUniformRoot<'a>>,
         path: &[Ident],
@@ -3749,7 +3754,6 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
         PathResult::Module(module.unwrap_or_else(|| {
             span_bug!(path_span, "resolve_path: empty(?) path {:?} has no module", path);
         }))
-
     }
 
     fn lint_if_path_starts_with_module(
@@ -4033,8 +4037,9 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
         } else {
             // Search in module.
             let mod_path = &path[..path.len() - 1];
-            if let PathResult::Module(module) = self.resolve_path(None, mod_path, Some(TypeNS),
-                                                                  false, span, CrateLint::No) {
+            if let PathResult::Module(module) = self.resolve_path_without_parent_scope(
+                None, mod_path, Some(TypeNS), false, span, CrateLint::No
+            ) {
                 if let ModuleOrUniformRoot::Module(module) = module {
                     add_module_candidates(module, &mut names);
                 }

src/librustc_resolve/macros.rs

@@ -462,7 +462,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         parent_scope: &ParentScope<'a>,
         force: bool,
     ) -> Result<Def, Determinacy> {
-        let ast::Path { ref segments, span } = *path;
+        let path_span = path.span;
         let mut path: Vec<_> = segments.iter().map(|seg| seg.ident).collect();
 
         // Possibly apply the macro helper hack
@@ -473,15 +473,15 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         }
 
         if path.len() > 1 {
-            let def = match self.resolve_path_with_parent_scope(None, &path, Some(MacroNS),
-                                                                parent_scope, false, span,
-                                                                CrateLint::No) {
+            let def = match self.resolve_path(None, &path, Some(MacroNS), parent_scope,
+                                              false, path_span, CrateLint::No) {
                 PathResult::NonModule(path_res) => match path_res.base_def() {
                     Def::Err => Err(Determinacy::Determined),
                     def @ _ => {
                         if path_res.unresolved_segments() > 0 {
                             self.found_unresolved_macro = true;
-                            self.session.span_err(span, "fail to resolve non-ident macro path");
+                            self.session.span_err(path_span,
+                                                  "fail to resolve non-ident macro path");
                             Err(Determinacy::Determined)
                         } else {
                             Ok(def)
@@ -497,12 +497,12 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
             };
 
             parent_scope.module.macro_resolutions.borrow_mut()
-                .push((path.into_boxed_slice(), span));
+                .push((path.into_boxed_slice(), parent_scope.clone(), span));
 
             def
         } else {
             let binding = self.early_resolve_ident_in_lexical_scope(
-                path[0], MacroNS, Some(kind), parent_scope, false, force, span
+                path[0], MacroNS, Some(kind), parent_scope, false, force, path_span
             );
             match binding {
                 Ok(..) => {}
@@ -846,8 +846,12 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
 
     pub fn finalize_current_module_macro_resolutions(&mut self) {
         let module = self.current_module;
-        for &(ref path, span) in module.macro_resolutions.borrow().iter() {
-            match self.resolve_path(None, &path, Some(MacroNS), true, span, CrateLint::No) {
+
+        let macro_resolutions =
+            mem::replace(&mut *module.macro_resolutions.borrow_mut(), Vec::new());
+        for (mut path, parent_scope, path_span) in macro_resolutions {
+            match self.resolve_path(None, &path, Some(MacroNS), &parent_scope,
+                                    true, path_span, CrateLint::No) {
                 PathResult::NonModule(_) => {},
                 PathResult::Failed(span, msg, _) => {
                     resolve_error(self, span, ResolutionError::FailedToResolve(&msg));

src/librustc_resolve/resolve_imports.rs

@@ -875,6 +875,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
                 }),
                 &directive.module_path[..],
                 None,
+                &directive.parent_scope,
                 false,
                 directive.span,
                 directive.crate_lint(),
@@ -954,6 +955,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
             }),
             &module_path,
             None,
+            &directive.parent_scope,
             true,
             span,
             directive.crate_lint(),
@@ -966,7 +968,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
             }
             PathResult::Failed(span, msg, true) => {
                 return if let Some(suggested_path) = self.make_path_suggestion(
-                    span, module_path.clone()
+                    span, module_path.clone(), &directive.parent_scope
                 ) {
                     Some((
                         span,