resolve: Resolve multi-segment imports using in-scope resolution on 2018 edition

Author: petrochenkov

src/librustc_resolve/build_reduced_graph.rs

@@ -125,36 +125,24 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         debug!("build_reduced_graph_for_use_tree(parent_prefix={:?}, use_tree={:?}, nested={})",
                parent_prefix, use_tree, nested);
 
-        let uniform_paths =
-            self.session.rust_2018() &&
-            self.session.features_untracked().uniform_paths;
-
-        let prefix_iter = || parent_prefix.iter().cloned()
-            .chain(use_tree.prefix.segments.iter().map(|seg| seg.ident));
-        let prefix_start = prefix_iter().next();
-        let starts_with_non_keyword = prefix_start.map_or(false, |ident| {
-            !ident.is_path_segment_keyword()
-        });
-
-        // Imports are resolved as global by default, prepend `CrateRoot`,
-        // unless `#![feature(uniform_paths)]` is enabled.
-        let inject_crate_root =
-            !uniform_paths &&
-            match use_tree.kind {
-                // HACK(eddyb) special-case `use *` to mean `use ::*`.
-                ast::UseTreeKind::Glob if prefix_start.is_none() => true,
-                _ => starts_with_non_keyword,
-            };
-        let root = if inject_crate_root {
-            let span = use_tree.prefix.span.shrink_to_lo();
-            Some(Ident::new(keywords::CrateRoot.name(), span))
+        let mut prefix_iter = parent_prefix.iter().cloned()
+            .chain(use_tree.prefix.segments.iter().map(|seg| seg.ident)).peekable();
+
+        // On 2015 edition imports are resolved as crate-relative by default,
+        // so prefixes are prepended with crate root segment if necessary.
+        // The root is prepended lazily, when the first non-empty prefix or terminating glob
+        // appears, so imports in braced groups can have roots prepended independently.
+        let is_glob = if let ast::UseTreeKind::Glob = use_tree.kind { true } else { false };
+        let crate_root = if !self.session.rust_2018() &&
+                prefix_iter.peek().map_or(is_glob, |ident| !ident.is_path_segment_keyword()) {
+            Some(Ident::new(keywords::CrateRoot.name(), use_tree.prefix.span.shrink_to_lo()))
         } else {
             None
         };
 
-        let prefix: Vec<_> = root.into_iter().chain(prefix_iter()).collect();
-
+        let prefix = crate_root.into_iter().chain(prefix_iter).collect::<Vec<_>>();
         debug!("build_reduced_graph_for_use_tree: prefix={:?}", prefix);
+
         let empty_for_self = |prefix: &[Ident]| {
             prefix.is_empty() ||
             prefix.len() == 1 && prefix[0].name == keywords::CrateRoot.name()

src/librustc_resolve/error_reporting.rs

@@ -68,7 +68,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
     ) -> Option<(Vec<Ident>, Option<String>)> {
         // 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, parent_scope, false, span, CrateLint::No);
+        let result = self.resolve_path(&path, None, parent_scope, false, span, CrateLint::No);
         debug!("make_missing_self_suggestion: path={:?} result={:?}", path, result);
         if let PathResult::Module(..) = result {
             Some((path, None))
@@ -92,7 +92,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
     ) -> Option<(Vec<Ident>, Option<String>)> {
         // 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, parent_scope, false, span, CrateLint::No);
+        let result = self.resolve_path(&path, None, parent_scope, false, span, CrateLint::No);
         debug!("make_missing_crate_suggestion:  path={:?} result={:?}", path, result);
         if let PathResult::Module(..) = result {
             Some((
@@ -123,7 +123,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
     ) -> Option<(Vec<Ident>, Option<String>)> {
         // 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, parent_scope, false, span, CrateLint::No);
+        let result = self.resolve_path(&path, None, parent_scope, false, span, CrateLint::No);
         debug!("make_missing_super_suggestion:  path={:?} result={:?}", path, result);
         if let PathResult::Module(..) = result {
             Some((path, None))
@@ -164,8 +164,7 @@ 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, parent_scope, false, span, CrateLint::No);
+            let result = self.resolve_path(&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

@@ -1621,7 +1621,7 @@ 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_without_parent_scope(None, &path, Some(namespace), true, span,
+        match self.resolve_path_without_parent_scope(&path, Some(namespace), true, span,
                                                      CrateLint::No) {
             PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                 *def = module.def().unwrap(),
@@ -2409,7 +2409,6 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
                 let span = trait_ref.path.span;
                 if let PathResult::Module(ModuleOrUniformRoot::Module(module)) =
                     self.resolve_path_without_parent_scope(
-                        None,
                         &path,
                         Some(TypeNS),
                         false,
@@ -2930,7 +2929,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
                 } else {
                     let mod_path = &path[..path.len() - 1];
                     let mod_prefix = match this.resolve_path_without_parent_scope(
-                        None, mod_path, Some(TypeNS), false, span, CrateLint::No
+                        mod_path, Some(TypeNS), false, span, CrateLint::No
                     ) {
                         PathResult::Module(ModuleOrUniformRoot::Module(module)) =>
                             module.def(),
@@ -3416,7 +3415,6 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
         }
 
         let result = match self.resolve_path_without_parent_scope(
-            None,
             &path,
             Some(ns),
             true,
@@ -3463,7 +3461,6 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
            path[0].name != keywords::DollarCrate.name() {
             let unqualified_result = {
                 match self.resolve_path_without_parent_scope(
-                    None,
                     &[*path.last().unwrap()],
                     Some(ns),
                     false,
@@ -3487,9 +3484,8 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
 
     fn resolve_path_without_parent_scope(
         &mut self,
-        base_module: Option<ModuleOrUniformRoot<'a>>,
         path: &[Ident],
-        opt_ns: Option<Namespace>, // `None` indicates a module path
+        opt_ns: Option<Namespace>, // `None` indicates a module path in import
         record_used: bool,
         path_span: Span,
         crate_lint: CrateLint,
@@ -3498,21 +3494,19 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
         // 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(base_module, path, opt_ns, &parent_scope,
-                          record_used, path_span, crate_lint)
+        self.resolve_path(path, opt_ns, &parent_scope, record_used, path_span, crate_lint)
     }
 
     fn resolve_path(
         &mut self,
-        base_module: Option<ModuleOrUniformRoot<'a>>,
         path: &[Ident],
-        opt_ns: Option<Namespace>, // `None` indicates a module path
+        opt_ns: Option<Namespace>, // `None` indicates a module path in import
         parent_scope: &ParentScope<'a>,
         record_used: bool,
         path_span: Span,
         crate_lint: CrateLint,
     ) -> PathResult<'a> {
-        let mut module = base_module;
+        let mut module = None;
         let mut allow_super = true;
         let mut second_binding = None;
         self.current_module = parent_scope.module;
@@ -3598,10 +3592,11 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
 
             let binding = if let Some(module) = module {
                 self.resolve_ident_in_module(module, ident, ns, record_used, path_span)
-            } else if opt_ns == Some(MacroNS) {
+            } else if opt_ns.is_none() || opt_ns == Some(MacroNS) {
                 assert!(ns == TypeNS);
-                self.early_resolve_ident_in_lexical_scope(ident, ns, None, parent_scope,
-                                                          record_used, record_used, path_span)
+                self.early_resolve_ident_in_lexical_scope(ident, ns, None, opt_ns.is_none(),
+                                                          parent_scope, record_used, record_used,
+                                                          path_span)
             } else {
                 let record_used_id =
                     if record_used { crate_lint.node_id().or(Some(CRATE_NODE_ID)) } else { None };
@@ -3686,9 +3681,11 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
 
         self.lint_if_path_starts_with_module(crate_lint, path, path_span, second_binding);
 
-        PathResult::Module(module.unwrap_or_else(|| {
-            span_bug!(path_span, "resolve_path: empty(?) path {:?} has no module", path);
-        }))
+        PathResult::Module(match module {
+            Some(module) => module,
+            None if path.is_empty() => ModuleOrUniformRoot::UniformRoot(keywords::Invalid.name()),
+            _ => span_bug!(path_span, "resolve_path: non-empty path `{:?}` has no module", path),
+        })
     }
 
     fn lint_if_path_starts_with_module(
@@ -3973,7 +3970,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> {
             // Search in module.
             let mod_path = &path[..path.len() - 1];
             if let PathResult::Module(module) = self.resolve_path_without_parent_scope(
-                None, mod_path, Some(TypeNS), false, span, CrateLint::No
+                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

@@ -473,7 +473,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         }
 
         if path.len() > 1 {
-            let def = match self.resolve_path(None, &path, Some(MacroNS), parent_scope,
+            let def = match self.resolve_path(&path, Some(MacroNS), parent_scope,
                                               false, path_span, CrateLint::No) {
                 PathResult::NonModule(path_res) => match path_res.base_def() {
                     Def::Err => Err(Determinacy::Determined),
@@ -502,7 +502,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
             def
         } else {
             let binding = self.early_resolve_ident_in_lexical_scope(
-                path[0], MacroNS, Some(kind), parent_scope, false, force, path_span
+                path[0], MacroNS, Some(kind), false, parent_scope, false, force, path_span
             );
             match binding {
                 Ok(..) => {}
@@ -521,12 +521,13 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
     // This is a variation of `fn resolve_ident_in_lexical_scope` that can be run during
     // expansion and import resolution (perhaps they can be merged in the future).
     // The function is used for resolving initial segments of macro paths (e.g. `foo` in
-    // `foo::bar!(); or `foo!();`) and can be used for "uniform path" imports in the future.
+    // `foo::bar!(); or `foo!();`) and also for import paths on 2018 edition.
     crate fn early_resolve_ident_in_lexical_scope(
         &mut self,
         mut ident: Ident,
         ns: Namespace,
-        kind: Option<MacroKind>,
+        macro_kind: Option<MacroKind>,
+        is_import: bool,
         parent_scope: &ParentScope<'a>,
         record_used: bool,
         force: bool,
@@ -600,6 +601,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         }
 
         assert!(force || !record_used); // `record_used` implies `force`
+        assert!(macro_kind.is_none() || !is_import); // `is_import` implies no macro kind
         ident = ident.modern();
 
         // This is *the* result, resolution from the scope closest to the resolved identifier.
@@ -788,7 +790,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
 
             match result {
                 Ok((binding, flags, ambig_flags)) => {
-                    if sub_namespace_mismatch(kind, binding.macro_kind()) {
+                    if sub_namespace_mismatch(macro_kind, binding.macro_kind()) {
                         continue_search!();
                     }
 
@@ -800,7 +802,8 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                             = innermost_result {
                         // Found another solution, if the first one was "weak", report an error.
                         if binding.def() != innermost_binding.def() &&
-                           (innermost_binding.is_glob_import() ||
+                           (is_import ||
+                            innermost_binding.is_glob_import() ||
                             innermost_binding.may_appear_after(parent_scope.expansion, binding) ||
                             innermost_flags.intersects(ambig_flags) ||
                             flags.intersects(innermost_ambig_flags) ||
@@ -834,7 +837,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         }
 
         let determinacy = Determinacy::determined(force);
-        if determinacy == Determinacy::Determined && kind == Some(MacroKind::Attr) {
+        if determinacy == Determinacy::Determined && macro_kind == Some(MacroKind::Attr) {
             // For single-segment attributes interpret determinate "no resolution" as a custom
             // attribute. (Lexical resolution implies the first segment and attr kind should imply
             // the last segment, so we are certainly working with a single-segment attribute here.)
@@ -854,7 +857,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         let macro_resolutions =
             mem::replace(&mut *module.macro_resolutions.borrow_mut(), Vec::new());
         for (path, parent_scope, path_span) in macro_resolutions {
-            match self.resolve_path(None, &path, Some(MacroNS), &parent_scope,
+            match self.resolve_path(&path, Some(MacroNS), &parent_scope,
                                     true, path_span, CrateLint::No) {
                 PathResult::NonModule(_) => {},
                 PathResult::Failed(span, msg, _) => {
@@ -868,7 +871,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
             mem::replace(&mut *module.legacy_macro_resolutions.borrow_mut(), Vec::new());
         for (ident, kind, parent_scope, initial_binding) in legacy_macro_resolutions {
             let binding = self.early_resolve_ident_in_lexical_scope(
-                ident, MacroNS, Some(kind), &parent_scope, true, true, ident.span
+                ident, MacroNS, Some(kind), false, &parent_scope, true, true, ident.span
             );
             match binding {
                 Ok(binding) => {
@@ -909,7 +912,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         let builtin_attrs = mem::replace(&mut *module.builtin_attrs.borrow_mut(), Vec::new());
         for (ident, parent_scope) in builtin_attrs {
             let binding = self.early_resolve_ident_in_lexical_scope(
-                ident, MacroNS, Some(MacroKind::Attr), &parent_scope, true, true, ident.span
+                ident, MacroNS, Some(MacroKind::Attr), false, &parent_scope, true, true, ident.span
             );
             if let Ok(binding) = binding {
                 if binding.def_ignoring_ambiguity() !=

src/librustc_resolve/resolve_imports.rs

@@ -152,10 +152,6 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> {
                 let can_be_relative = !ident.is_path_segment_keyword() &&
                     root == keywords::Invalid.name();
                 if can_be_relative {
-                    // Relative paths should only get here if the feature-gate is on.
-                    assert!(self.session.rust_2018() &&
-                            self.session.features_untracked().uniform_paths);
-
                     // Try first to resolve relatively.
                     let mut ctxt = ident.span.ctxt().modern();
                     let self_module = self.resolve_self(&mut ctxt, self.current_module);
@@ -748,7 +744,6 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
             // while resolving its module path.
             directive.vis.set(ty::Visibility::Invisible);
             let result = self.resolve_path(
-                Some(ModuleOrUniformRoot::UniformRoot(keywords::Invalid.name())),
                 &directive.module_path[..],
                 None,
                 &directive.parent_scope,
@@ -827,7 +822,6 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> {
         let ImportDirective { ref module_path, span, .. } = *directive;
 
         let module_result = self.resolve_path(
-            Some(ModuleOrUniformRoot::UniformRoot(keywords::Invalid.name())),
             &module_path,
             None,
             &directive.parent_scope,