Rollup of 5 pull requests

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1763,10 +1763,6 @@ fn link_output_kind(sess: &Session, crate_type: CrateType) -> LinkOutputKind {
 
 // Returns true if linker is located within sysroot
 fn detect_self_contained_mingw(sess: &Session, linker: &Path) -> bool {
-    // Assume `-C linker=rust-lld` as self-contained mode
-    if linker == Path::new("rust-lld") {
-        return true;
-    }
     let linker_with_extension = if cfg!(windows) && linker.extension().is_none() {
         linker.with_extension("exe")
     } else {

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -13,7 +13,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_hir::{AmbigArg, ItemKind, find_attr};
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::infer::{self, InferCtxt, SubregionOrigin, TyCtxtInferExt};
-use rustc_lint_defs::builtin::SUPERTRAIT_ITEM_SHADOWING_DEFINITION;
+use rustc_lint_defs::builtin::SHADOWING_SUPERTRAIT_ITEMS;
 use rustc_macros::LintDiagnostic;
 use rustc_middle::mir::interpret::ErrorHandled;
 use rustc_middle::traits::solve::NoSolution;
@@ -797,7 +797,7 @@ fn lint_item_shadowing_supertrait_item<'tcx>(tcx: TyCtxt<'tcx>, trait_item_def_i
         };
 
         tcx.emit_node_span_lint(
-            SUPERTRAIT_ITEM_SHADOWING_DEFINITION,
+            SHADOWING_SUPERTRAIT_ITEMS,
             tcx.local_def_id_to_hir_id(trait_item_def_id),
             tcx.def_span(trait_item_def_id),
             errors::SupertraitItemShadowing {

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -12,7 +12,7 @@ use rustc_hir_analysis::hir_ty_lowering::{
 use rustc_infer::infer::{
     BoundRegionConversionTime, DefineOpaqueTypes, InferOk, RegionVariableOrigin,
 };
-use rustc_lint::builtin::SUPERTRAIT_ITEM_SHADOWING_USAGE;
+use rustc_lint::builtin::RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS;
 use rustc_middle::traits::ObligationCauseCode;
 use rustc_middle::ty::adjustment::{
     Adjust, Adjustment, AllowTwoPhase, AutoBorrow, AutoBorrowMutability, PointerCoercion,
@@ -709,7 +709,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         };
 
         self.tcx.emit_node_span_lint(
-            SUPERTRAIT_ITEM_SHADOWING_USAGE,
+            RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS,
             segment.hir_id,
             segment.ident.span,
             SupertraitItemShadowing { shadower, shadowee, item: segment.ident.name, subtrait },

compiler/rustc_lint_defs/src/builtin.rs

@@ -88,6 +88,7 @@ declare_lint_pass! {
         RENAMED_AND_REMOVED_LINTS,
         REPR_C_ENUMS_LARGER_THAN_INT,
         REPR_TRANSPARENT_NON_ZST_FIELDS,
+        RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS,
         RTSAN_NONBLOCKING_ASYNC,
         RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
         RUST_2021_INCOMPATIBLE_OR_PATTERNS,
@@ -98,11 +99,10 @@ declare_lint_pass! {
         RUST_2024_PRELUDE_COLLISIONS,
         SELF_CONSTRUCTOR_FROM_OUTER_ITEM,
         SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
+        SHADOWING_SUPERTRAIT_ITEMS,
         SINGLE_USE_LIFETIMES,
         SOFT_UNSTABLE,
         STABLE_FEATURES,
-        SUPERTRAIT_ITEM_SHADOWING_DEFINITION,
-        SUPERTRAIT_ITEM_SHADOWING_USAGE,
         TAIL_EXPR_DROP_ORDER,
         TEST_UNSTABLE_LINT,
         TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
@@ -4922,15 +4922,16 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `supertrait_item_shadowing_usage` lint detects when the
+    /// The `resolving_to_items_shadowing_supertrait_items` lint detects when the
     /// usage of an item that is provided by both a subtrait and supertrait
     /// is shadowed, preferring the subtrait.
     ///
     /// ### Example
     ///
-    /// ```rust,compile_fail
+    #[cfg_attr(bootstrap, doc = "```ignore")]
+    #[cfg_attr(not(bootstrap), doc = "```rust,compile_fail")]
     /// #![feature(supertrait_item_shadowing)]
-    /// #![deny(supertrait_item_shadowing_usage)]
+    /// #![deny(resolving_to_items_shadowing_supertrait_items)]
     ///
     /// trait Upstream {
     ///     fn hello(&self) {}
@@ -4944,7 +4945,8 @@ declare_lint! {
     ///
     /// struct MyType;
     /// MyType.hello();
-    /// ```
+    #[cfg_attr(bootstrap, doc = "```")]
+    #[cfg_attr(not(bootstrap), doc = "```")]
     ///
     /// {{produces}}
     ///
@@ -4955,7 +4957,7 @@ declare_lint! {
     /// selection. In order to mitigate side-effects of this happening
     /// silently, this lint detects these cases when users want to deny them
     /// or fix the call sites.
-    pub SUPERTRAIT_ITEM_SHADOWING_USAGE,
+    pub RESOLVING_TO_ITEMS_SHADOWING_SUPERTRAIT_ITEMS,
     // FIXME(supertrait_item_shadowing): It is not decided if this should
     // warn by default at the call site.
     Allow,
@@ -4964,15 +4966,16 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `supertrait_item_shadowing_definition` lint detects when the
+    /// The `shadowing_supertrait_items` lint detects when the
     /// definition of an item that is provided by both a subtrait and
     /// supertrait is shadowed, preferring the subtrait.
     ///
     /// ### Example
     ///
-    /// ```rust,compile_fail
+    #[cfg_attr(bootstrap, doc = "```ignore")]
+    #[cfg_attr(not(bootstrap), doc = "```rust,compile_fail")]
     /// #![feature(supertrait_item_shadowing)]
-    /// #![deny(supertrait_item_shadowing_definition)]
+    /// #![deny(shadowing_supertrait_items)]
     ///
     /// trait Upstream {
     ///     fn hello(&self) {}
@@ -4983,7 +4986,8 @@ declare_lint! {
     ///     fn hello(&self) {}
     /// }
     /// impl<T> Downstream for T {}
-    /// ```
+    #[cfg_attr(bootstrap, doc = "```")]
+    #[cfg_attr(not(bootstrap), doc = "```")]
     ///
     /// {{produces}}
     ///
@@ -4994,7 +4998,7 @@ declare_lint! {
     /// selection. In order to mitigate side-effects of this happening
     /// silently, this lint detects these cases when users want to deny them
     /// or fix their trait definitions.
-    pub SUPERTRAIT_ITEM_SHADOWING_DEFINITION,
+    pub SHADOWING_SUPERTRAIT_ITEMS,
     // FIXME(supertrait_item_shadowing): It is not decided if this should
     // warn by default at the usage site.
     Allow,

library/core/src/mem/mod.rs

@@ -898,8 +898,6 @@ pub const fn replace<T>(dest: &mut T, src: T) -> T {
 
 /// Disposes of a value.
 ///
-/// This does so by calling the argument's implementation of [`Drop`][drop].
-///
 /// This effectively does nothing for types which implement `Copy`, e.g.
 /// integers. Such values are copied and _then_ moved into the function, so the
 /// value persists after this function call.
@@ -910,7 +908,7 @@ pub const fn replace<T>(dest: &mut T, src: T) -> T {
 /// pub fn drop<T>(_x: T) {}
 /// ```
 ///
-/// Because `_x` is moved into the function, it is automatically dropped before
+/// Because `_x` is moved into the function, it is automatically [dropped][drop] before
 /// the function returns.
 ///
 /// [drop]: Drop

library/coretests/tests/convert.rs

@@ -14,3 +14,20 @@ fn convert() {
     const BAR: Vec<String> = into(Vec::new());
     assert_eq!(BAR, Vec::<String>::new());
 }
+
+#[test]
+fn into_as_try_into() {
+    struct A;
+    struct B;
+
+    impl Into<B> for A {
+        fn into(self) -> B {
+            B
+        }
+    }
+
+    // This wouldn't compile if the `TryInto`/`TryFrom` blanket impls used
+    // `U: From<T>` instead of `T: Into<U>`
+    let Ok(B) = A.try_into();
+    let Ok(B) = B::try_from(A);
+}

tests/ui/README.md

@@ -941,6 +941,8 @@ Contains a single test. It imports a massive amount of very similar types from a
 
 ## `tests/ui/never_type/`
 
+Tests relating to the never type. Most tests are specifically about the never type fallback behavior.
+
 See [Tracking issue for promoting `!` to a type (RFC 1216) #35121](https://github.com/rust-lang/rust/issues/35121).
 
 ## `tests/ui/new-range/`

tests/ui/coercion/coerce-issue-49593-box-never.e2021.stderr

@@ -0,0 +1,19 @@
+error[E0277]: the trait bound `(): std::error::Error` is not satisfied
+  --> $DIR/coerce-issue-49593-box-never.rs:28:5
+   |
+LL |     Box::new(x)
+   |     ^^^^^^^^^^^ the trait `std::error::Error` is not implemented for `()`
+   |
+   = note: required for the cast from `Box<()>` to `Box<(dyn std::error::Error + 'static)>`
+
+error[E0277]: the trait bound `(): std::error::Error` is not satisfied
+  --> $DIR/coerce-issue-49593-box-never.rs:33:5
+   |
+LL |     raw_ptr(x)
+   |     ^^^^^^^^^^ the trait `std::error::Error` is not implemented for `()`
+   |
+   = note: required for the cast from `*mut ()` to `*mut (dyn std::error::Error + 'static)`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

tests/ui/coercion/coerce-issue-49593-box-never.rs

@@ -1,57 +1,37 @@
-//@ revisions: nofallback fallback
-//@[fallback] edition: 2024
-//@[fallback] check-pass
+// Regression test for <https://github.com/rust-lang/rust/issues/49593>.
+//
+// This checks that we can construct `Box<dyn Error>` by calling `Box::new`
+// with a value of the never type. And similarly for raw pointers.
+//
+// This used to fail because we tried to coerce `! -> dyn Error`, which then
+// failed because we were trying to pass an unsized value by value, etc.
+//
+// On edition <= 2021 this currently fails because of never type fallback to
+// unit.
+//
+//@ revisions: e2021 e2024
+//@[e2021] edition: 2021
+//@[e2024] edition: 2024
+//
+//@[e2024] check-pass
 
 #![feature(never_type)]
 
 use std::error::Error;
 use std::mem;
 
-fn raw_ptr_box<T>(t: T) -> *mut T {
+fn raw_ptr<T>(t: T) -> *mut T {
     panic!()
 }
 
 fn foo(x: !) -> Box<dyn Error> {
-    // Method resolution will generate new inference vars and relate them.
-    // Thus fallback will not fall back to `!`, but `()` instead.
-    Box::<_ /* ! */>::new(x)
-    //[nofallback]~^ ERROR trait bound `(): std::error::Error` is not satisfied
+    Box::new(x)
+    //[e2021]~^ ERROR trait bound `(): std::error::Error` is not satisfied
 }
 
 fn foo_raw_ptr(x: !) -> *mut dyn Error {
-    /* *mut $0 is coerced to *mut Error here */
-    raw_ptr_box::<_ /* ! */>(x)
-    //[nofallback]~^ ERROR trait bound `(): std::error::Error` is not satisfied
-}
-
-fn no_coercion(d: *mut dyn Error) -> *mut dyn Error {
-    /* an unsize coercion won't compile here, and it is indeed not used
-    because there is nothing requiring the _ to be Sized */
-    d as *mut _
-}
-
-trait Xyz {}
-struct S;
-struct T;
-impl Xyz for S {}
-impl Xyz for T {}
-
-fn foo_no_never() {
-    let mut x /* : Option<S> */ = None;
-    let mut first_iter = false;
-    loop {
-        if !first_iter {
-            let y: Box<dyn Xyz>
-                = /* Box<$0> is coerced to Box<Xyz> here */ Box::new(x.unwrap());
-        }
-
-        x = Some(S);
-        first_iter = true;
-    }
-
-    let mut y: Option<S> = None;
-    // assert types are equal
-    mem::swap(&mut x, &mut y);
+    raw_ptr(x)
+    //[e2021]~^ ERROR trait bound `(): std::error::Error` is not satisfied
 }
 
 fn main() {}