diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 92a9057d96ebc..a1e602efd0d5b 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -194,7 +194,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> { // ergonomically unacceptable. let emit_uniform_paths_canary = !uniform_paths_canary_emitted && - uniform_paths && + self.session.rust_2018() && starts_with_non_keyword; if emit_uniform_paths_canary { let source = prefix_start.unwrap(); diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 73c9af0d11c47..994ed39d6e639 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -708,6 +708,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> { } } + let uniform_paths_feature = self.session.features_untracked().uniform_paths; for ((span, _), (name, results)) in uniform_paths_canaries { self.per_ns(|this, ns| { let results = &results[ns]; @@ -739,15 +740,24 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> { suggestion_choices.push_str(" or "); } write!(suggestion_choices, "`self::{}`", name); - err.span_label(span, - format!("can refer to `self::{}`", name)); + if uniform_paths_feature { + err.span_label(span, + format!("can refer to `self::{}`", name)); + } else { + err.span_label(span, + format!("may refer to `self::{}` in the future", name)); + } } for &span in &results.block_scopes { err.span_label(span, format!("shadowed by block-scoped `{}`", name)); } err.help(&format!("write {} explicitly instead", suggestion_choices)); - err.note("relative `use` paths enabled by `#![feature(uniform_paths)]`"); + if uniform_paths_feature { + err.note("relative `use` paths enabled by `#![feature(uniform_paths)]`"); + } else { + err.note("in the future, `#![feature(uniform_paths)]` may become the default"); + } err.emit(); }); } @@ -933,11 +943,15 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> { _ => unreachable!(), }; + // Do not record uses from canaries, to avoid interfering with other + // diagnostics or suggestions that rely on some items not being used. + let record_used = !directive.is_uniform_paths_canary; + let mut all_ns_err = true; self.per_ns(|this, ns| if !type_ns_only || ns == TypeNS { if let Ok(binding) = result[ns].get() { all_ns_err = false; - if this.record_use(ident, ns, binding, directive.span) { + if record_used && this.record_use(ident, ns, binding, directive.span) { if let ModuleOrUniformRoot::Module(module) = module { this.resolution(module, ident, ns).borrow_mut().binding = Some(this.dummy_binding); @@ -949,7 +963,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> { if all_ns_err { let mut all_ns_failed = true; self.per_ns(|this, ns| if !type_ns_only || ns == TypeNS { - match this.resolve_ident_in_module(module, ident, ns, true, span) { + match this.resolve_ident_in_module(module, ident, ns, record_used, span) { Ok(_) => all_ns_failed = false, _ => {} } diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs new file mode 100644 index 0000000000000..590e83b07819a --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.rs @@ -0,0 +1,29 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// edition:2018 + +// This test is similar to `ambiguity-macros.rs`, but nested in a module. + +mod foo { + pub use std::io; + //~^ ERROR `std` import is ambiguous + + macro_rules! m { + () => { + mod std { + pub struct io; + } + } + } + m!(); +} + +fn main() {} diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr new file mode 100644 index 0000000000000..948043cff7614 --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros-nested.stderr @@ -0,0 +1,16 @@ +error: `std` import is ambiguous + --> $DIR/ambiguity-macros-nested.rs:16:13 + | +LL | pub use std::io; + | ^^^ can refer to external crate `::std` +... +LL | / mod std { +LL | | pub struct io; +LL | | } + | |_____________- may refer to `self::std` in the future + | + = help: write `::std` or `self::std` explicitly instead + = note: in the future, `#![feature(uniform_paths)]` may become the default + +error: aborting due to previous error + diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs new file mode 100644 index 0000000000000..861efba14f80c --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.rs @@ -0,0 +1,27 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// edition:2018 + +// This test is similar to `ambiguity.rs`, but with macros defining local items. + +use std::io; +//~^ ERROR `std` import is ambiguous + +macro_rules! m { + () => { + mod std { + pub struct io; + } + } +} +m!(); + +fn main() {} diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr new file mode 100644 index 0000000000000..40cceea2440b9 --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-macros.stderr @@ -0,0 +1,16 @@ +error: `std` import is ambiguous + --> $DIR/ambiguity-macros.rs:15:5 + | +LL | use std::io; + | ^^^ can refer to external crate `::std` +... +LL | / mod std { +LL | | pub struct io; +LL | | } + | |_________- may refer to `self::std` in the future + | + = help: write `::std` or `self::std` explicitly instead + = note: in the future, `#![feature(uniform_paths)]` may become the default + +error: aborting due to previous error + diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs new file mode 100644 index 0000000000000..a69eb101917fa --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.rs @@ -0,0 +1,24 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// edition:2018 + +// This test is similar to `ambiguity.rs`, but nested in a module. + +mod foo { + pub use std::io; + //~^ ERROR `std` import is ambiguous + + mod std { + pub struct io; + } +} + +fn main() {} diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr new file mode 100644 index 0000000000000..7538d3d2d917a --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity-nested.stderr @@ -0,0 +1,16 @@ +error: `std` import is ambiguous + --> $DIR/ambiguity-nested.rs:16:13 + | +LL | pub use std::io; + | ^^^ can refer to external crate `::std` +... +LL | / mod std { +LL | | pub struct io; +LL | | } + | |_____- may refer to `self::std` in the future + | + = help: write `::std` or `self::std` explicitly instead + = note: in the future, `#![feature(uniform_paths)]` may become the default + +error: aborting due to previous error + diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs new file mode 100644 index 0000000000000..500e9f6c63ff8 --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.rs @@ -0,0 +1,20 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// edition:2018 + +use std::io; +//~^ ERROR `std` import is ambiguous + +mod std { + pub struct io; +} + +fn main() {} diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr new file mode 100644 index 0000000000000..7b64b8f02464a --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/ambiguity.stderr @@ -0,0 +1,16 @@ +error: `std` import is ambiguous + --> $DIR/ambiguity.rs:13:5 + | +LL | use std::io; + | ^^^ can refer to external crate `::std` +... +LL | / mod std { +LL | | pub struct io; +LL | | } + | |_- may refer to `self::std` in the future + | + = help: write `::std` or `self::std` explicitly instead + = note: in the future, `#![feature(uniform_paths)]` may become the default + +error: aborting due to previous error + diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/block-scoped-shadow.rs b/src/test/ui/rust-2018/uniform-paths-forward-compat/block-scoped-shadow.rs new file mode 100644 index 0000000000000..ca488fec5162d --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/block-scoped-shadow.rs @@ -0,0 +1,21 @@ +// Copyright 2018 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// edition:2018 + +struct std; + +fn main() { + fn std() {} + enum std {} + use std as foo; + //~^ ERROR `std` import is ambiguous + //~| ERROR `std` import is ambiguous +} diff --git a/src/test/ui/rust-2018/uniform-paths-forward-compat/block-scoped-shadow.stderr b/src/test/ui/rust-2018/uniform-paths-forward-compat/block-scoped-shadow.stderr new file mode 100644 index 0000000000000..27e0e88369127 --- /dev/null +++ b/src/test/ui/rust-2018/uniform-paths-forward-compat/block-scoped-shadow.stderr @@ -0,0 +1,31 @@ +error: `std` import is ambiguous + --> $DIR/block-scoped-shadow.rs:18:9 + | +LL | struct std; + | ----------- may refer to `self::std` in the future +... +LL | enum std {} + | ----------- shadowed by block-scoped `std` +LL | use std as foo; + | ^^^ can refer to external crate `::std` + | + = help: write `::std` or `self::std` explicitly instead + = note: in the future, `#![feature(uniform_paths)]` may become the default + +error: `std` import is ambiguous + --> $DIR/block-scoped-shadow.rs:18:9 + | +LL | struct std; + | ----------- may refer to `self::std` in the future +... +LL | fn std() {} + | ----------- shadowed by block-scoped `std` +LL | enum std {} +LL | use std as foo; + | ^^^ + | + = help: write `self::std` explicitly instead + = note: in the future, `#![feature(uniform_paths)]` may become the default + +error: aborting due to 2 previous errors +