Support self appear at the end of any paths, and lint redundant self

Author: mu001999

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_lint_defs/src/builtin.rs

@@ -86,6 +86,7 @@ declare_lint_pass! {
         PUB_USE_OF_PRIVATE_EXTERN_CRATE,
         REDUNDANT_IMPORTS,
         REDUNDANT_LIFETIMES,
+        REDUNDANT_SELF,
         REFINING_IMPL_TRAIT_INTERNAL,
         REFINING_IMPL_TRAIT_REACHABLE,
         RENAMED_AND_REMOVED_LINTS,
@@ -1759,6 +1760,28 @@ declare_lint! {
     "detects lifetime parameters that are redundant because they are equal to some other named lifetime"
 }
 
+declare_lint! {
+    /// The `redundant_self` lint detects unnecessary `self` in `use` imports.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// use foo::self;
+    /// use foo::self as bar;
+    /// use foo::{self};
+    /// use foo::{self as bar};
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// The `self` segment is redundant in these forms and can be removed.
+    pub REDUNDANT_SELF,
+    Warn,
+    "detects redundant `self` in imports",
+}
+
 declare_lint! {
     /// The `tyvar_behind_raw_pointer` lint detects raw pointer to an
     /// inference variable.

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -25,6 +25,7 @@ use rustc_metadata::creader::LoadedMacro;
 use rustc_middle::metadata::{ModChild, Reexport};
 use rustc_middle::ty::{Feed, Visibility};
 use rustc_middle::{bug, span_bug};
+use rustc_session::lint::builtin::REDUNDANT_SELF;
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind};
 use rustc_span::{Ident, Span, Symbol, kw, sym};
 use thin_vec::ThinVec;
@@ -37,8 +38,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>;
@@ -626,8 +627,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 let mut module_path = prefix;
                 let mut source = module_path.pop().unwrap();
 
-                // `true` for `...::{self [as target]}` imports, `false` otherwise.
-                let type_ns_only = nested && source.ident.name == kw::SelfLower;
+                let type_ns_only = source.ident.name == kw::SelfLower;
 
                 match source.ident.name {
                     kw::DollarCrate => {
@@ -666,22 +666,19 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     }
                     kw::SelfLower => {
                         if 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))
-                            {
-                                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,
-                                    },
+                            // `true` for `...::{self [as target]}` imports, `false` otherwise.
+                            let nested_self = nested
+                                && source.ident.name == kw::SelfLower
+                                && use_tree.prefix.segments.len() == 1;
+
+                            // Lint `use ...::self [as target];`
+                            if !nested_self && parent.ident.name != kw::PathRoot {
+                                let span = parent.ident.span.shrink_to_hi().to(source.ident.span);
+                                self.r.lint_buffer().buffer_lint(
+                                    REDUNDANT_SELF,
+                                    item.id,
+                                    source.ident.span,
+                                    errors::RedundantSelfDiag::Remove { span },
                                 );
                             }
 
@@ -706,16 +703,10 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 // 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;
                 }
 
@@ -745,7 +736,33 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     }
                 }
             }
-            ast::UseTreeKind::Nested { ref items, .. } => {
+            ast::UseTreeKind::Nested { ref items, span } => {
+                // Lint `use ...::{self [as target]};`
+                if let Some(parent) = prefix.last()
+                    && parent.ident.name != kw::PathRoot
+                    && let [(tree, _)] = &items[..]
+                    && let ast::UseTreeKind::Simple(rename) = tree.kind
+                    && let [segment] = &tree.prefix.segments[..]
+                    && segment.ident.name == kw::SelfLower
+                {
+                    let span = parent.ident.span.shrink_to_hi().to(span);
+                    if let Some(rename) = rename {
+                        self.r.lint_buffer().buffer_lint(
+                            REDUNDANT_SELF,
+                            item.id,
+                            segment.ident.span,
+                            errors::RedundantSelfDiag::Replace { span, rename },
+                        );
+                    } else {
+                        self.r.lint_buffer().buffer_lint(
+                            REDUNDANT_SELF,
+                            item.id,
+                            segment.ident.span,
+                            errors::RedundantSelfDiag::Remove { span },
+                        );
+                    }
+                }
+
                 for &(ref tree, id) in items {
                     self.build_reduced_graph_for_use_tree(
                         // This particular use tree

compiler/rustc_resolve/src/diagnostics.rs

@@ -870,29 +870,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> {
@@ -968,7 +934,7 @@ pub(crate) struct UnnamedImport {
     #[primary_span]
     pub(crate) span: Span,
     #[subdiagnostic]
-    pub(crate) sugg: Option<UnnamedImportSugg>,
+    pub(crate) sugg: UnnamedImportSugg,
 }
 
 #[derive(Diagnostic)]
@@ -1565,3 +1531,22 @@ impl<'a> LintDiagnostic<'a, ()> for Ambiguity {
         self.decorate(diag);
     }
 }
+
+#[derive(LintDiagnostic)]
+pub(crate) enum RedundantSelfDiag {
+    #[diag("unnecessary `self`")]
+    Remove {
+        #[suggestion("consider removing this", code = "", applicability = "machine-applicable")]
+        span: Span,
+    },
+    #[diag("unnecessary `self`")]
+    Replace {
+        #[suggestion(
+            "consider replacing this with",
+            code = " as {rename}",
+            applicability = "machine-applicable"
+        )]
+        span: Span,
+        rename: Ident,
+    },
+}

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,