Support trailing self in paths

compiler/rustc_error_codes/src/error_codes/E0429.md

@@ -1,9 +1,11 @@
+#### Note: this error code is no longer emitted by the compiler.
+
 The `self` keyword cannot appear alone as the last segment in a `use`
 declaration.
 
 Erroneous code example:
 
-```compile_fail,E0429
+```ignore (error is no longer emitted)
 use std::fmt::self; // error: `self` imports are only allowed within a { } list
 ```
 

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -37,8 +37,8 @@ use crate::macros::{MacroRulesDecl, MacroRulesScope, MacroRulesScopeRef};
 use crate::ref_mut::CmCell;
 use crate::{
     BindingKey, Decl, DeclData, DeclKind, ExternPreludeEntry, Finalize, IdentKey, MacroData,
-    Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, ResolutionError, Resolver,
-    Segment, Used, VisResolutionError, errors,
+    Module, ModuleKind, ModuleOrUniformRoot, ParentScope, PathResult, Resolver, Segment, Used,
+    VisResolutionError, errors,
 };
 
 type Res = def::Res<NodeId>;
@@ -622,41 +622,27 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
 
         match use_tree.kind {
             ast::UseTreeKind::Simple(rename) => {
-                let mut ident = use_tree.ident();
                 let mut module_path = prefix;
-                let mut source = module_path.pop().unwrap();
+                let source = module_path.pop().unwrap();
 
-                // `true` for `...::{self [as target]}` imports, `false` otherwise.
-                let type_ns_only = nested && source.ident.name == kw::SelfLower;
-
-                if source.ident.name == kw::SelfLower
-                    && let Some(parent) = module_path.pop()
-                {
-                    // Suggest `use prefix::{self};` for `use prefix::self;`
-                    if !type_ns_only
-                        && (parent.ident.name != kw::PathRoot
-                            || self.r.path_root_is_crate_root(parent.ident))
+                // normalize `self::self` to `self`
+                if source.ident.name == kw::SelfLower {
+                    while let Some(parent) = module_path.last()
+                        && parent.ident.name == kw::SelfLower
                     {
-                        let span_with_rename = match rename {
-                            Some(rename) => source.ident.span.to(rename.span),
-                            None => source.ident.span,
-                        };
-
-                        self.r.report_error(
-                            parent.ident.span.shrink_to_hi().to(source.ident.span),
-                            ResolutionError::SelfImportsOnlyAllowedWithin {
-                                root: parent.ident.name == kw::PathRoot,
-                                span_with_rename,
-                            },
-                        );
+                        module_path.pop();
                     }
+                }
 
+                let ident = if source.ident.name == kw::SelfLower
+                    && rename.is_none()
+                    && let Some(parent) = module_path.last()
+                {
                     let self_span = source.ident.span;
-                    source = parent;
-                    if rename.is_none() {
-                        ident = Ident::new(source.ident.name, self_span);
-                    }
-                }
+                    Ident::new(parent.ident.name, self_span)
+                } else {
+                    use_tree.ident()
+                };
 
                 match source.ident.name {
                     kw::DollarCrate => {
@@ -693,35 +679,48 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                             return;
                         }
                     }
-                    // Deny `use ::{self};` after edition 2015
-                    kw::PathRoot if !self.r.path_root_is_crate_root(source.ident) => {
-                        self.r.dcx().span_err(use_tree.span, "extern prelude cannot be imported");
-                        return;
+                    kw::SelfLower => {
+                        // Deny `use ::{self};` after edition 2015
+                        if let Some(parent) = module_path.last()
+                            && parent.ident.name == kw::PathRoot
+                            && !self.r.path_root_is_crate_root(parent.ident)
+                        {
+                            self.r
+                                .dcx()
+                                .span_err(use_tree.span, "extern prelude cannot be imported");
+                            return;
+                        }
+                    }
+                    _ => {
+                        // Deny `use ...::self::foo [as name];`
+                        if module_path.len() > 1
+                            && let Some(parent) = module_path.last()
+                            && parent.ident.name == kw::SelfLower
+                        {
+                            self.r.dcx().span_err(
+                                parent.ident.span,
+                                "`self` in paths can only be used in start position",
+                            );
+                            return;
+                        }
                     }
-                    _ => {}
                 }
 
                 // Deny importing path-kw without renaming
                 if rename.is_none() && ident.is_path_segment_keyword() {
                     let ident = use_tree.ident();
-
-                    // Don't suggest `use xx::self as name;` for `use xx::self;`
-                    // But it's OK to suggest `use xx::{self as name};` for `use xx::{self};`
-                    let sugg = if !type_ns_only && ident.name == kw::SelfLower {
-                        None
-                    } else {
-                        Some(errors::UnnamedImportSugg { span: ident.span, ident })
-                    };
-
-                    self.r.dcx().emit_err(errors::UnnamedImport { span: ident.span, sugg });
+                    self.r.dcx().emit_err(errors::UnnamedImport {
+                        span: ident.span,
+                        sugg: errors::UnnamedImportSugg { span: ident.span, ident },
+                    });
                     return;
                 }
 
                 let kind = ImportKind::Single {
                     source: source.ident,
                     target: ident,
                     decls: Default::default(),
-                    type_ns_only,
+                    type_ns_only: source.ident.is_path_segment_keyword(),
                     nested,
                     id,
                 };

compiler/rustc_resolve/src/diagnostics.rs

@@ -369,9 +369,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let mut suggestion = None;
         let mut span = binding_span;
         match import.kind {
-            ImportKind::Single { type_ns_only: true, .. } => {
-                suggestion = Some(format!("self as {suggested_name}"))
-            }
             ImportKind::Single { source, .. } => {
                 if let Some(pos) = source.span.hi().0.checked_sub(binding_span.lo().0)
                     && let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(binding_span)
@@ -870,29 +867,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     sub_unreachable,
                 })
             }
-            ResolutionError::SelfImportsOnlyAllowedWithin { root, span_with_rename } => {
-                // None of the suggestions below would help with a case like `use self`.
-                let (suggestion, mpart_suggestion) = if root {
-                    (None, None)
-                } else {
-                    // use foo::bar::self        -> foo::bar
-                    // use foo::bar::self as abc -> foo::bar as abc
-                    let suggestion = errs::SelfImportsOnlyAllowedWithinSuggestion { span };
-
-                    // use foo::bar::self        -> foo::bar::{self}
-                    // use foo::bar::self as abc -> foo::bar::{self as abc}
-                    let mpart_suggestion = errs::SelfImportsOnlyAllowedWithinMultipartSuggestion {
-                        multipart_start: span_with_rename.shrink_to_lo(),
-                        multipart_end: span_with_rename.shrink_to_hi(),
-                    };
-                    (Some(suggestion), Some(mpart_suggestion))
-                };
-                self.dcx().create_err(errs::SelfImportsOnlyAllowedWithin {
-                    span,
-                    suggestion,
-                    mpart_suggestion,
-                })
-            }
             ResolutionError::FailedToResolve { segment, label, suggestion, module, message } => {
                 let mut err = struct_span_code_err!(self.dcx(), span, E0433, "{message}");
                 err.span_label(span, label);

compiler/rustc_resolve/src/errors.rs

@@ -300,40 +300,6 @@ pub(crate) struct AttemptToUseNonConstantValueInConstantWithoutSuggestion<'a> {
     pub(crate) suggestion: &'a str,
 }
 
-#[derive(Diagnostic)]
-#[diag("`self` imports are only allowed within a {\"{\"} {\"}\"} list", code = E0429)]
-pub(crate) struct SelfImportsOnlyAllowedWithin {
-    #[primary_span]
-    pub(crate) span: Span,
-    #[subdiagnostic]
-    pub(crate) suggestion: Option<SelfImportsOnlyAllowedWithinSuggestion>,
-    #[subdiagnostic]
-    pub(crate) mpart_suggestion: Option<SelfImportsOnlyAllowedWithinMultipartSuggestion>,
-}
-
-#[derive(Subdiagnostic)]
-#[suggestion(
-    "consider importing the module directly",
-    code = "",
-    applicability = "machine-applicable"
-)]
-pub(crate) struct SelfImportsOnlyAllowedWithinSuggestion {
-    #[primary_span]
-    pub(crate) span: Span,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(
-    "alternatively, use the multi-path `use` syntax to import `self`",
-    applicability = "machine-applicable"
-)]
-pub(crate) struct SelfImportsOnlyAllowedWithinMultipartSuggestion {
-    #[suggestion_part(code = "{{")]
-    pub(crate) multipart_start: Span,
-    #[suggestion_part(code = "}}")]
-    pub(crate) multipart_end: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("{$shadowing_binding}s cannot shadow {$shadowed_binding}s", code = E0530)]
 pub(crate) struct BindingShadowsSomethingUnacceptable<'a> {
@@ -978,7 +944,7 @@ pub(crate) struct UnnamedImport {
     #[primary_span]
     pub(crate) span: Span,
     #[subdiagnostic]
-    pub(crate) sugg: Option<UnnamedImportSugg>,
+    pub(crate) sugg: UnnamedImportSugg,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_resolve/src/ident.rs

@@ -953,12 +953,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     ) -> Result<Decl<'ra>, Determinacy> {
         match module {
             ModuleOrUniformRoot::Module(module) => {
-                if ns == TypeNS
-                    && ident.name == kw::Super
-                    && let Some(module) =
-                        self.resolve_super_in_module(ident, Some(module), parent_scope)
-                {
-                    return Ok(module.self_decl.unwrap());
+                if ns == TypeNS {
+                    if ident.name == kw::SelfLower {
+                        return Ok(module.self_decl.unwrap());
+                    }
+                    if ident.name == kw::Super
+                        && let Some(module) =
+                            self.resolve_super_in_module(ident, Some(module), parent_scope)
+                    {
+                        return Ok(module.self_decl.unwrap());
+                    }
                 }
 
                 let (ident_key, def) = IdentKey::new_adjusted(ident, module.expansion);
@@ -1018,7 +1022,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     {
                         let module = self.resolve_crate_root(ident);
                         return Ok(module.self_decl.unwrap());
-                    } else if ident.name == kw::Super || ident.name == kw::SelfLower {
+                    } else if ident.name == kw::Super {
                         // FIXME: Implement these with renaming requirements so that e.g.
                         // `use super;` doesn't work, but `use super as name;` does.
                         // Fall through here to get an error from `early_resolve_...`.
@@ -1827,6 +1831,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         },
                     );
                 }
+
                 if segment_idx == 0 {
                     if name == kw::SelfLower {
                         let mut ctxt = ident.span.ctxt().normalize_to_macros_2_0();
@@ -1860,6 +1865,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         continue;
                     }
                 }
+
+                // Support `...::self`, but deny `::self` after edition 2018
+                if is_last
+                    && name == kw::SelfLower
+                    && segment_idx > 0
+                    && (path[segment_idx - 1].ident.name != kw::PathRoot
+                        || self.path_root_is_crate_root(path[segment_idx - 1].ident))
+                {
+                    continue;
+                }
             }
 
             // Report special messages for path segment keywords in wrong positions.

compiler/rustc_resolve/src/imports.rs

@@ -68,7 +68,7 @@ pub(crate) enum ImportKind<'ra> {
         target: Ident,
         /// Name declarations introduced by the import.
         decls: PerNS<CmCell<PendingDecl<'ra>>>,
-        /// `true` for `...::{self [as target]}` imports, `false` otherwise.
+        /// `true` for `crate`/`$crate`/`super`/`self` imports, `false` otherwise.
         type_ns_only: bool,
         /// Did this import result from a nested import? ie. `use foo::{bar, baz};`
         nested: bool,

compiler/rustc_resolve/src/lib.rs

@@ -272,8 +272,6 @@ enum ResolutionError<'ra> {
     IdentifierBoundMoreThanOnceInSamePattern(Ident),
     /// Error E0426: use of undeclared label.
     UndeclaredLabel { name: Symbol, suggestion: Option<LabelSuggestion> },
-    /// Error E0429: `self` imports are only allowed within a `{ }` list.
-    SelfImportsOnlyAllowedWithin { root: bool, span_with_rename: Span },
     /// Error E0433: failed to resolve.
     FailedToResolve {
         segment: Symbol,
@@ -2504,7 +2502,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
 fn names_to_string(names: impl Iterator<Item = Symbol>) -> String {
     let mut result = String::new();
-    for (i, name) in names.filter(|name| *name != kw::PathRoot).enumerate() {
+    for (i, name) in names.enumerate() {
+        if name == kw::PathRoot {
+            continue;
+        }
+
         if i > 0 {
             result.push_str("::");
         }

tests/ui/error-codes/E0429.rs

@@ -1,4 +1,6 @@
-use std::fmt::self; //~ ERROR E0429
+//@ check-pass
+
+use std::fmt::self;
 
 fn main () {
 }

tests/ui/imports/absolute-paths-in-nested-use-groups.stderr

@@ -1,3 +1,9 @@
+error: `self` in paths can only be used in start position
+  --> $DIR/absolute-paths-in-nested-use-groups.rs:10:5
+   |
+LL |     self::bar,
+   |     ^^^^
+
 error[E0433]: the crate root in paths can only be used in start position
   --> $DIR/absolute-paths-in-nested-use-groups.rs:6:5
    |
@@ -10,12 +16,6 @@ error[E0433]: `super` in paths can only be used in start position
 LL |     super::bar,
    |     ^^^^^ can only be used in path start position
 
-error[E0433]: `self` in paths can only be used in start position
-  --> $DIR/absolute-paths-in-nested-use-groups.rs:10:5
-   |
-LL |     self::bar,
-   |     ^^^^ can only be used in path start position
-
 error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0433`.

tests/ui/imports/cycle-import-in-std-1.stderr

@@ -1,11 +1,13 @@
 error[E0432]: unresolved import `ops`
-  --> $DIR/cycle-import-in-std-1.rs:5:11
+  --> $DIR/cycle-import-in-std-1.rs:5:5
    |
 LL | use ops::{self as std};
-   |           ^^^^^^^^^^^ no external crate `ops`
+   |     ^^^
    |
-   = help: consider importing this module instead:
-           std::ops
+help: a similar path exists
+   |
+LL | use core::ops::{self as std};
+   |     ++++++
 
 error: aborting due to 1 previous error