Auto merge of #143629 - oli-obk:limited-nonzero-coercion, r=<try>

Limited nonzero coercion

coercing `NonZero<T>` to `T` if all the types are available at the cast site.

This is fairly limited, as (as the tests show), this does not allow "reborrowing" `&NonZero<T>` as `&T`. It also fails quickly if the types aren't fully clear at the coercion site, but only resolved later.

Also cannot aid in trait selection or similar, even if there is clearly only one option.

Related:

* #143594
* rust-lang/rfcs#3786

cc `@traviscross`

Author: rust-bors[bot]

compiler/rustc_hir/src/lang_items.rs

@@ -426,6 +426,8 @@ language_item_table! {
     String,                  sym::String,              string,                     Target::Struct,         GenericRequirement::None;
     CStr,                    sym::CStr,                c_str,                      Target::Struct,         GenericRequirement::None;
 
+    NonZero,                 sym::NonZero,             non_zero,                   Target::Struct,         GenericRequirement::Exact(1);
+
     // Experimental lang items for implementing contract pre- and post-condition checking.
     ContractBuildCheckEnsures, sym::contract_build_check_ensures, contract_build_check_ensures_fn, Target::Fn, GenericRequirement::None;
     ContractCheckRequires,     sym::contract_check_requires,      contract_check_requires_fn,      Target::Fn, GenericRequirement::None;

compiler/rustc_hir_typeck/src/coercion.rs

@@ -263,6 +263,9 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 // It cannot convert closures that require unsafe.
                 self.coerce_closure_to_fn(a, closure_def_id_a, args_a, b)
             }
+            ty::Adt(adt, args) if self.tcx.is_lang_item(adt.did(), hir::LangItem::NonZero) => {
+                self.coerce_non_zero(a, args.type_at(0), b)
+            }
             _ => {
                 // Otherwise, just use unification rules.
                 self.unify(a, b)
@@ -827,6 +830,19 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         self.unify_and(a, b, [], Adjust::ReborrowPin(mut_b))
     }
 
+    fn coerce_non_zero(
+        &self,
+        non_zero: Ty<'tcx>,
+        wrapped_ty: Ty<'tcx>,
+        target_ty: Ty<'tcx>,
+    ) -> CoerceResult<'tcx> {
+        if target_ty.is_ty_var() {
+            return self.unify(non_zero, target_ty);
+        }
+        self.commit_if_ok(|_| self.unify_and(wrapped_ty, target_ty, [], Adjust::NonZeroIntoInner))
+            .or_else(|_| self.unify(non_zero, target_ty))
+    }
+
     fn coerce_from_safe_fn(
         &self,
         fn_ty_a: ty::PolyFnSig<'tcx>,

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -854,6 +854,8 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     };
                     self.delegate.borrow_mut().borrow(&place_with_id, place_with_id.hir_id, bk);
                 }
+
+                adjustment::Adjust::NonZeroIntoInner => {}
             }
             place_with_id = self.cat_expr_adjusted(expr, place_with_id, adjustment)?;
         }
@@ -1336,6 +1338,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
             adjustment::Adjust::NeverToAny
             | adjustment::Adjust::Pointer(_)
             | adjustment::Adjust::Borrow(_)
+            | adjustment::Adjust::NonZeroIntoInner
             | adjustment::Adjust::ReborrowPin(..) => {
                 // Result is an rvalue.
                 Ok(self.cat_rvalue(expr.hir_id, target))

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -290,7 +290,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     // FIXME(const_trait_impl): We could enforce these; they correspond to
                     // `&mut T: DerefMut` tho, so it's kinda moot.
                 }
-                Adjust::Borrow(_) => {
+                Adjust::NonZeroIntoInner | Adjust::Borrow(_) => {
                     // No effects to enforce here.
                 }
             }

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -2487,7 +2487,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             _ => return false,
         };
 
-        if !self.tcx.is_diagnostic_item(sym::NonZero, adt.did()) {
+        if !self.tcx.is_lang_item(adt.did(), LangItem::NonZero) {
             return false;
         }
 

compiler/rustc_lint/src/autorefs.rs

@@ -171,6 +171,7 @@ fn has_implicit_borrow(Adjustment { kind, .. }: &Adjustment<'_>) -> Option<(Muta
         | Adjust::Pointer(..)
         | Adjust::ReborrowPin(..)
         | Adjust::Deref(None)
+        | Adjust::NonZeroIntoInner
         | Adjust::Borrow(AutoBorrow::RawPtr(..)) => None,
     }
 }

compiler/rustc_middle/src/ty/adjustment.rs

@@ -105,6 +105,9 @@ pub enum Adjust {
 
     /// Take a pinned reference and reborrow as a `Pin<&mut T>` or `Pin<&T>`.
     ReborrowPin(hir::Mutability),
+
+    /// Turn a `NonZero<T>` into `T`
+    NonZeroIntoInner,
 }
 
 /// An overloaded autoderef step, representing a `Deref(Mut)::deref(_mut)`

compiler/rustc_mir_build/src/thir/cx/expr.rs

@@ -239,6 +239,34 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 debug!(?kind);
                 kind
             }
+            Adjust::NonZeroIntoInner => {
+                // These only happen on `NonZero`
+                let ty::Adt(adt, args) = expr.ty.kind() else {
+                    span_bug!(span, "nonzero adjustment not based on adt: {expr:#?}")
+                };
+                // Find the right field type
+                let ty = self
+                    .tcx
+                    .type_of(adt.variant(FIRST_VARIANT).fields[FieldIdx::ZERO].did)
+                    .instantiate(self.tcx, args);
+                // Get rid of the `ZeroablePrimitive` projection
+                let ty = self.tcx.normalize_erasing_regions(self.typing_env, ty);
+                let lhs = self.thir.exprs.push(expr);
+                ExprKind::Field {
+                    lhs: self.thir.exprs.push(Expr {
+                        span,
+                        temp_lifetime,
+                        ty,
+                        kind: ExprKind::Field {
+                            lhs,
+                            variant_index: FIRST_VARIANT,
+                            name: FieldIdx::ZERO,
+                        },
+                    }),
+                    variant_index: FIRST_VARIANT,
+                    name: FieldIdx::ZERO,
+                }
+            }
         };
 
         Expr { temp_lifetime, ty: adjustment.target, span, kind }

library/core/src/num/nonzero.rs

@@ -123,7 +123,7 @@ impl_zeroable_primitive!(
 #[stable(feature = "generic_nonzero", since = "1.79.0")]
 #[repr(transparent)]
 #[rustc_nonnull_optimization_guaranteed]
-#[rustc_diagnostic_item = "NonZero"]
+#[lang = "NonZero"]
 pub struct NonZero<T: ZeroablePrimitive>(T::NonZeroInner);
 
 macro_rules! impl_nonzero_fmt {

src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs

@@ -2,9 +2,9 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::is_inside_always_const_context;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::ty::is_type_lang_item;
 use rustc_errors::Applicability;
-use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, Node, QPath, UnsafeSource};
+use rustc_hir::{Block, BlockCheckMode, Expr, ExprKind, LangItem, Node, QPath, UnsafeSource};
 use rustc_lint::LateContext;
 use rustc_span::sym;
 
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, func: &Expr<'
         && segment.ident.name == sym::new_unchecked
         && let [init_arg] = args
         && is_inside_always_const_context(cx.tcx, expr.hir_id)
-        && is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::NonZero)
+        && is_type_lang_item(cx, cx.typeck_results().node_type(ty.hir_id), LangItem::NonZero)
         && msrv.meets(cx, msrvs::CONST_UNWRAP)
     {
         let mut app = Applicability::MachineApplicable;