resolve: Stop generating uniform path canaries

Author: petrochenkov

src/librustc_resolve/build_reduced_graph.rs

@@ -116,17 +116,14 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         id: NodeId,
         parent_prefix: &[Ident],
         nested: bool,
-        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);
+        debug!("build_reduced_graph_for_use_tree(parent_prefix={:?}, use_tree={:?}, nested={})",
+               parent_prefix, use_tree, nested);
 
         let uniform_paths =
             self.session.rust_2018() &&
@@ -158,98 +155,6 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
         let prefix: Vec<_> = root.into_iter().chain(prefix_iter()).collect();
 
         debug!("build_reduced_graph_for_use_tree: prefix={:?}", prefix);
-
-        // `#[feature(uniform_paths)]` allows an unqualified import path,
-        // e.g. `use x::...;` to resolve not just globally (`use ::x::...;`)
-        // but also relatively (`use self::x::...;`). To catch ambiguities
-        // that might arise from both of these being available and resolution
-        // silently picking one of them, an artificial `use self::x as _;`
-        // import is injected as a "canary", and an error is emitted if it
-        // successfully resolves while an `x` external crate exists.
-        //
-        // For each block scope around the `use` item, one special canary
-        // import of the form `use x as _;` is also injected, having its
-        // parent set to that scope; `resolve_imports` will only resolve
-        // it within its appropriate scope; if any of them successfully
-        // resolve, an ambiguity error is emitted, since the original
-        // import can't see the item in the block scope (`self::x` only
-        // looks in the enclosing module), but a non-`use` path could.
-        //
-        // Additionally, the canary might be able to catch limitations of the
-        // current implementation, where `::x` may be chosen due to `self::x`
-        // not existing, but `self::x` could appear later, from macro expansion.
-        //
-        // NB. The canary currently only errors if the `x::...` path *could*
-        // resolve as a relative path through the extern crate, i.e. `x` is
-        // in `extern_prelude`, *even though* `::x` might still forcefully
-        // load a non-`extern_prelude` crate.
-        // While always producing an ambiguity errors if `self::x` exists and
-        // a crate *could* be loaded, would be more conservative, imports for
-        // local modules named `test` (or less commonly, `syntax` or `log`),
-        // would need to be qualified (e.g. `self::test`), which is considered
-        // ergonomically unacceptable.
-        let emit_uniform_paths_canary =
-            !uniform_paths_canary_emitted &&
-            self.session.rust_2018() &&
-            starts_with_non_keyword;
-        if emit_uniform_paths_canary {
-            let source = prefix_start.unwrap();
-
-            // Helper closure to emit a canary with the given base path.
-            let emit = |this: &mut Self, base: Option<Ident>| {
-                let subclass = SingleImport {
-                    target: Ident {
-                        name: keywords::Underscore.name().gensymed(),
-                        span: source.span,
-                    },
-                    source,
-                    result: PerNS {
-                        type_ns: Cell::new(Err(Undetermined)),
-                        value_ns: Cell::new(Err(Undetermined)),
-                        macro_ns: Cell::new(Err(Undetermined)),
-                    },
-                    type_ns_only: false,
-                };
-                this.add_import_directive(
-                    base.into_iter().collect(),
-                    subclass,
-                    source.span,
-                    id,
-                    root_span,
-                    item.id,
-                    ty::Visibility::Invisible,
-                    parent_scope.clone(),
-                    true, // is_uniform_paths_canary
-                );
-            };
-
-            // A single simple `self::x` canary.
-            emit(self, Some(Ident {
-                name: keywords::SelfValue.name(),
-                span: source.span,
-            }));
-
-            // One special unprefixed canary per block scope around
-            // the import, to detect items unreachable by `self::x`.
-            let orig_current_module = self.current_module;
-            let mut span = source.span.modern();
-            loop {
-                match self.current_module.kind {
-                    ModuleKind::Block(..) => emit(self, None),
-                    ModuleKind::Def(..) => break,
-                }
-                match self.hygienic_lexical_parent(self.current_module, &mut span) {
-                    Some(module) => {
-                        self.current_module = module;
-                    }
-                    None => break,
-                }
-            }
-            self.current_module = orig_current_module;
-
-            uniform_paths_canary_emitted = true;
-        }
-
         let empty_for_self = |prefix: &[Ident]| {
             prefix.is_empty() ||
             prefix.len() == 1 && prefix[0].name == keywords::CrateRoot.name()
@@ -344,7 +249,6 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     item.id,
                     vis,
                     parent_scope,
-                    false, // is_uniform_paths_canary
                 );
             }
             ast::UseTreeKind::Glob => {
@@ -361,7 +265,6 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     item.id,
                     vis,
                     parent_scope,
-                    false, // is_uniform_paths_canary
                 );
             }
             ast::UseTreeKind::Nested(ref items) => {
@@ -390,7 +293,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                 for &(ref tree, id) in items {
                     self.build_reduced_graph_for_use_tree(
                         // This particular use tree
-                        tree, id, &prefix, true, uniform_paths_canary_emitted,
+                        tree, id, &prefix, true,
                         // The whole `use` item
                         parent_scope.clone(), item, vis, root_span,
                     );
@@ -414,7 +317,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     };
                     self.build_reduced_graph_for_use_tree(
                         // This particular use tree
-                        &tree, id, &prefix, true, uniform_paths_canary_emitted,
+                        &tree, id, &prefix, true,
                         // The whole `use` item
                         parent_scope.clone(), item, ty::Visibility::Invisible, root_span,
                     );
@@ -435,7 +338,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
             ItemKind::Use(ref use_tree) => {
                 self.build_reduced_graph_for_use_tree(
                     // This particular use tree
-                    use_tree, item.id, &[], false, false,
+                    use_tree, item.id, &[], false,
                     // The whole `use` item
                     parent_scope, item, vis, use_tree.span,
                 );
@@ -486,7 +389,6 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
                     module_path: Vec::new(),
                     vis: Cell::new(vis),
                     used: Cell::new(used),
-                    is_uniform_paths_canary: false,
                 });
                 self.potentially_unused_imports.push(directive);
                 let imported_binding = self.import(binding, directive);
@@ -899,7 +801,6 @@ impl<'a, 'cl> Resolver<'a, 'cl> {
             module_path: Vec::new(),
             vis: Cell::new(ty::Visibility::Restricted(DefId::local(CRATE_DEF_INDEX))),
             used: Cell::new(false),
-            is_uniform_paths_canary: false,
         });
 
         let allow_shadowing = parent_scope.expansion == Mark::root();