Add ambiguous_panic_imports lint

Voultapher · Voultapher · commit bdc4c56ab47e · 2025-10-04T10:32:42.000+02:00
This turns the ambiguous panic import error into a warning to avoid
breaking large parts of the Rust crate ecosystem.
diff --git a/compiler/rustc_lint/src/early/diagnostics.rs b/compiler/rustc_lint/src/early/diagnostics.rs
@@ -257,8 +257,8 @@ pub fn decorate_builtin_lint(
 
             lints::ExternCrateNotIdiomatic { span: suggestion_span, code }.decorate_lint(diag);
         }
-        BuiltinLintDiag::AmbiguousGlobImports { diag: ambiguity } => {
-            lints::AmbiguousGlobImports { ambiguity }.decorate_lint(diag);
+        BuiltinLintDiag::AmbiguousImports { diag: ambiguity } => {
+            lints::AmbiguousImports { ambiguity }.decorate_lint(diag);
         }
         BuiltinLintDiag::AmbiguousGlobReexports {
             name,
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
@@ -2863,11 +2863,11 @@ pub(crate) struct ExternCrateNotIdiomatic {
 }
 
 // FIXME: make this translatable
-pub(crate) struct AmbiguousGlobImports {
+pub(crate) struct AmbiguousImports {
     pub ambiguity: AmbiguityErrorDiag,
 }
 
-impl<'a, G: EmissionGuarantee> LintDiagnostic<'a, G> for AmbiguousGlobImports {
+impl<'a, G: EmissionGuarantee> LintDiagnostic<'a, G> for AmbiguousImports {
     fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>) {
         diag.primary_message(self.ambiguity.msg.clone());
         rustc_errors::report_ambiguity_error(diag, self.ambiguity);
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
@@ -21,6 +21,7 @@ declare_lint_pass! {
         AMBIGUOUS_ASSOCIATED_ITEMS,
         AMBIGUOUS_GLOB_IMPORTS,
         AMBIGUOUS_GLOB_REEXPORTS,
+        AMBIGUOUS_PANIC_IMPORTS,
         ARITHMETIC_OVERFLOW,
         ASM_SUB_REGISTER,
         BAD_ASM_STYLE,
@@ -4438,6 +4439,43 @@ declare_lint! {
     };
 }
 
+declare_lint! {
+    /// The `ambiguous_panic_imports` lint detects ambiguous core and std panic imports, but
+    /// previously didn't do that due to `#[macro_use]` prelude macro import.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// #![deny(ambiguous_panic_imports)]
+    /// #![no_std]
+    ///
+    /// extern crate std;
+    /// use std::prelude::v1::*;
+    ///
+    /// fn xx() {
+    ///     panic!(); // resolves to core::panic
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Future versions of Rust will no longer accept the ambiguous resolution.
+    ///
+    /// This is a [future-incompatible] lint to transition this to a hard error in the future.
+    ///
+    /// [future-incompatible]: ../index.md#future-incompatible-lints
+    pub AMBIGUOUS_PANIC_IMPORTS,
+    Warn,
+    "detects ambiguous core and std panic imports",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: FutureIncompatibilityReason::FutureReleaseError,
+        reference: "issue #147319 <https://github.com/rust-lang/rust/issues/147319>",
+        report_in_deps: true,
+    };
+}
+
 declare_lint! {
     /// The `refining_impl_trait_reachable` lint detects `impl Trait` return
     /// types in method signatures that are refined by a publically reachable
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
@@ -682,7 +682,7 @@ pub enum BuiltinLintDiag {
         vis_span: Span,
         ident_span: Span,
     },
-    AmbiguousGlobImports {
+    AmbiguousImports {
         diag: AmbiguityErrorDiag,
     },
     AmbiguousGlobReexports {
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
@@ -21,7 +21,7 @@ use rustc_middle::bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_session::lint::builtin::{
-    ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE, AMBIGUOUS_GLOB_IMPORTS,
+    ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE, AMBIGUOUS_GLOB_IMPORTS, AMBIGUOUS_PANIC_IMPORTS,
     MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
 };
 use rustc_session::lint::{AmbiguityErrorDiag, BuiltinLintDiag};
@@ -42,9 +42,9 @@ use crate::errors::{
 use crate::imports::{Import, ImportKind};
 use crate::late::{PatternSource, Rib};
 use crate::{
-    AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingError, BindingKey, Finalize,
-    ForwardGenericParamBanReason, HasGenericParams, LexicalScopeBinding, MacroRulesScope, Module,
-    ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult,
+    AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, AmbiguityWarning, BindingError, BindingKey,
+    Finalize, ForwardGenericParamBanReason, HasGenericParams, LexicalScopeBinding, MacroRulesScope,
+    Module, ModuleKind, ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult,
     PrivacyError, ResolutionError, Resolver, Scope, ScopeSet, Segment, UseError, Used,
     VisResolutionError, errors as errs, path_names_to_string,
 };
@@ -144,15 +144,21 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         for ambiguity_error in &self.ambiguity_errors {
             let diag = self.ambiguity_diagnostics(ambiguity_error);
-            if ambiguity_error.warning {
+            if let Some(ambiguity_warning) = ambiguity_error.warning {
                 let NameBindingKind::Import { import, .. } = ambiguity_error.b1.0.kind else {
                     unreachable!()
                 };
+
+                let lint = match ambiguity_warning {
+                    AmbiguityWarning::GlobImport => AMBIGUOUS_GLOB_IMPORTS,
+                    AmbiguityWarning::PanicImport => AMBIGUOUS_PANIC_IMPORTS,
+                };
+
                 self.lint_buffer.buffer_lint(
-                    AMBIGUOUS_GLOB_IMPORTS,
+                    lint,
                     import.root_id,
                     ambiguity_error.ident.span,
-                    BuiltinLintDiag::AmbiguousGlobImports { diag },
+                    BuiltinLintDiag::AmbiguousImports { diag },
                 );
             } else {
                 let mut err = struct_span_code_err!(self.dcx(), diag.span, E0659, "{}", diag.msg);
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
@@ -15,10 +15,10 @@ use crate::imports::{Import, NameResolution};
 use crate::late::{ConstantHasGenerics, NoConstantGenericsReason, PathSource, Rib, RibKind};
 use crate::macros::{MacroRulesScope, sub_namespace_match};
 use crate::{
-    AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, BindingKey, CmResolver, Determinacy,
-    Finalize, ImportKind, LexicalScopeBinding, Module, ModuleKind, ModuleOrUniformRoot,
-    NameBinding, NameBindingKind, ParentScope, PathResult, PrivacyError, Res, ResolutionError,
-    Resolver, Scope, ScopeSet, Segment, Stage, Used, Weak, errors,
+    AmbiguityError, AmbiguityErrorMisc, AmbiguityKind, AmbiguityWarning, BindingKey, CmResolver,
+    Determinacy, Finalize, ImportKind, LexicalScopeBinding, Module, ModuleKind,
+    ModuleOrUniformRoot, NameBinding, NameBindingKind, ParentScope, PathResult, PrivacyError, Res,
+    ResolutionError, Resolver, Scope, ScopeSet, Segment, Stage, Used, Weak, errors,
 };
 
 #[derive(Copy, Clone)]
@@ -697,13 +697,34 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                 // Skip ambiguity errors for extern flag bindings "overridden"
                                 // by extern item bindings.
                                 // FIXME: Remove with lang team approval.
-                                let issue_145575_hack = Some(binding)
-                                    == extern_prelude_flag_binding
-                                    && extern_prelude_item_binding.is_some()
-                                    && extern_prelude_item_binding != Some(innermost_binding);
+                                let is_issue_145575_hack = || {
+                                    Some(binding) == extern_prelude_flag_binding
+                                        && extern_prelude_item_binding.is_some()
+                                        && extern_prelude_item_binding != Some(innermost_binding)
+                                };
+
                                 if let Some(kind) = ambiguity_error_kind
-                                    && !issue_145575_hack
+                                    && !is_issue_145575_hack()
                                 {
+                                    // Turn ambiguity errors for core vs std panic into warnings.
+                                    // FIXME: Remove with lang team approval.
+                                    let is_issue_147319_hack = matches!(
+                                        (binding.res(), innermost_binding.res()),
+                                        (
+                                            Res::Def(DefKind::Macro(_), def_id_core),
+                                            Res::Def(DefKind::Macro(_), def_id_std)
+                                        ) if this.tcx.def_path_debug_str(def_id_core)
+                                                == "core[234c]::macros::panic"
+                                            && this.tcx.def_path_debug_str(def_id_std)
+                                                == "std[d474]::macros::panic"
+                                    );
+
+                                    let warning = if is_issue_147319_hack {
+                                        Some(AmbiguityWarning::PanicImport)
+                                    } else {
+                                        None
+                                    };
+
                                     let misc = |f: Flags| {
                                         if f.contains(Flags::MISC_SUGGEST_CRATE) {
                                             AmbiguityErrorMisc::SuggestCrate
@@ -720,7 +741,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                                         ident: orig_ident,
                                         b1: innermost_binding,
                                         b2: binding,
-                                        warning: false,
+                                        warning,
                                         misc1: misc(innermost_flags),
                                         misc2: misc(flags),
                                     });
@@ -1064,7 +1085,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 ident,
                 b1: binding,
                 b2: shadowed_glob,
-                warning: false,
+                warning: None,
                 misc1: AmbiguityErrorMisc::None,
                 misc2: AmbiguityErrorMisc::None,
             });
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
@@ -957,8 +957,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ImportKind::Single { bindings, .. } => bindings[TypeNS].get().binding(),
             _ => None,
         };
-        let ambiguity_errors_len =
-            |errors: &Vec<AmbiguityError<'_>>| errors.iter().filter(|error| !error.warning).count();
+        let ambiguity_errors_len = |errors: &Vec<AmbiguityError<'_>>| {
+            errors.iter().filter(|error| error.warning.is_none()).count()
+        };
         let prev_ambiguity_errors_len = ambiguity_errors_len(&self.ambiguity_errors);
         let finalize = Finalize::with_root_span(import.root_id, import.span, import.root_span);
 
@@ -1173,7 +1174,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         });
                         let res = binding.res();
                         let has_ambiguity_error =
-                            this.ambiguity_errors.iter().any(|error| !error.warning);
+                            this.ambiguity_errors.iter().any(|error| error.warning.is_none());
                         if res == Res::Err || has_ambiguity_error {
                             this.dcx()
                                 .span_delayed_bug(import.span, "some error happened for an import");
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -903,14 +903,20 @@ enum AmbiguityErrorMisc {
     None,
 }
 
+#[derive(Clone, Copy, PartialEq)]
+enum AmbiguityWarning {
+    GlobImport,
+    PanicImport,
+}
+
 struct AmbiguityError<'ra> {
     kind: AmbiguityKind,
     ident: Ident,
     b1: NameBinding<'ra>,
     b2: NameBinding<'ra>,
     misc1: AmbiguityErrorMisc,
     misc2: AmbiguityErrorMisc,
-    warning: bool,
+    warning: Option<AmbiguityWarning>,
 }
 
 impl<'ra> NameBindingData<'ra> {
@@ -2046,7 +2052,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 b2,
                 misc1: AmbiguityErrorMisc::None,
                 misc2: AmbiguityErrorMisc::None,
-                warning: warn_ambiguity,
+                warning: if warn_ambiguity { Some(AmbiguityWarning::GlobImport) } else { None },
             };
             if !self.matches_previous_ambiguity_error(&ambiguity_error) {
                 // avoid duplicated span information to be emit out
diff --git a/tests/ui/imports/ambiguous-panic.rs b/tests/ui/imports/ambiguous-panic.rs
@@ -0,0 +1,13 @@
+#![deny(ambiguous_panic_imports)]
+#![crate_type = "lib"]
+#![no_std]
+
+extern crate std;
+use std::prelude::v1::*;
+
+#[allow(unused)]
+fn xx() {
+    panic!();
+    //~^ ERROR `panic` is ambiguous
+    //~| WARNING this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+}
diff --git a/tests/ui/imports/ambiguous-panic.stderr b/tests/ui/imports/ambiguous-panic.stderr
@@ -0,0 +1,51 @@
+error: `panic` is ambiguous
+  --> $DIR/ambiguous-panic.rs:10:5
+   |
+LL |     panic!();
+   |     ^^^^^ ambiguous name
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #147319 <https://github.com/rust-lang/rust/issues/147319>
+   = note: ambiguous because of a conflict between a name from a glob import and an outer scope during import or macro resolution
+note: `panic` could refer to the macro imported here
+  --> $DIR/ambiguous-panic.rs:6:5
+   |
+LL | use std::prelude::v1::*;
+   |     ^^^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `panic` to disambiguate
+   = help: or use `crate::panic` to refer to this macro unambiguously
+note: `panic` could also refer to a macro from prelude
+  --> $SRC_DIR/core/src/prelude/mod.rs:LL:COL
+note: the lint level is defined here
+  --> $DIR/ambiguous-panic.rs:1:9
+   |
+LL | #![deny(ambiguous_panic_imports)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+Future incompatibility report: Future breakage diagnostic:
+error: `panic` is ambiguous
+  --> $DIR/ambiguous-panic.rs:10:5
+   |
+LL |     panic!();
+   |     ^^^^^ ambiguous name
+   |
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #147319 <https://github.com/rust-lang/rust/issues/147319>
+   = note: ambiguous because of a conflict between a name from a glob import and an outer scope during import or macro resolution
+note: `panic` could refer to the macro imported here
+  --> $DIR/ambiguous-panic.rs:6:5
+   |
+LL | use std::prelude::v1::*;
+   |     ^^^^^^^^^^^^^^^^^^^
+   = help: consider adding an explicit import of `panic` to disambiguate
+   = help: or use `crate::panic` to refer to this macro unambiguously
+note: `panic` could also refer to a macro from prelude
+  --> $SRC_DIR/core/src/prelude/mod.rs:LL:COL
+note: the lint level is defined here
+  --> $DIR/ambiguous-panic.rs:1:9
+   |
+LL | #![deny(ambiguous_panic_imports)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+

Original file line number	Diff line number	Diff line change
`@@ -257,8 +257,8 @@ pub fn decorate_builtin_lint(`
`257`	`257`
`258`	`258`	`lints::ExternCrateNotIdiomatic { span: suggestion_span, code }.decorate_lint(diag);`
`259`	`259`	`}`
`260`		`- BuiltinLintDiag::AmbiguousGlobImports { diag: ambiguity } => {`
`261`		`- lints::AmbiguousGlobImports { ambiguity }.decorate_lint(diag);`
	`260`	`+ BuiltinLintDiag::AmbiguousImports { diag: ambiguity } => {`
	`261`	`+ lints::AmbiguousImports { ambiguity }.decorate_lint(diag);`
`262`	`262`	`}`
`263`	`263`	`BuiltinLintDiag::AmbiguousGlobReexports {`
`264`	`264`	`name,`
Original file line number	Diff line number	Diff line change
`@@ -2863,11 +2863,11 @@ pub(crate) struct ExternCrateNotIdiomatic {`
`2863`	`2863`	`}`
`2864`	`2864`
`2865`	`2865`	`// FIXME: make this translatable`
`2866`		`-pub(crate) struct AmbiguousGlobImports {`
	`2866`	`+pub(crate) struct AmbiguousImports {`
`2867`	`2867`	`pub ambiguity: AmbiguityErrorDiag,`
`2868`	`2868`	`}`
`2869`	`2869`
`2870`		`-impl<'a, G: EmissionGuarantee> LintDiagnostic<'a, G> for AmbiguousGlobImports {`
	`2870`	`+impl<'a, G: EmissionGuarantee> LintDiagnostic<'a, G> for AmbiguousImports {`
`2871`	`2871`	`fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>) {`
`2872`	`2872`	`diag.primary_message(self.ambiguity.msg.clone());`
`2873`	`2873`	`rustc_errors::report_ambiguity_error(diag, self.ambiguity);`