Allow coercing NonZero<T> to T

Author: oli-obk

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_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 }

tests/ui/mismatched_types/non_zero_coerce.rs

@@ -0,0 +1,32 @@
+//@ check-pass
+
+use std::num::NonZero;
+
+trait Foo<T>: Sized {
+    fn bar(self, other: T) {}
+}
+
+impl Foo<u8> for u8 {}
+impl Foo<u16> for u16 {}
+
+trait Bar {}
+impl Bar for u8 {}
+impl Bar for u16 {}
+fn foo(_: impl Bar) {}
+
+fn main() {
+    // Check that we can coerce
+    let x = NonZero::new(5_u8).unwrap();
+    let y: u8 = x;
+
+    // Can coerce by looking at the trait
+    let x = NonZero::new(5_u8).unwrap();
+    5_u8.bar(x);
+
+    // Check that we can infer the nonzero wrapped type through the coercion
+    let a = NonZero::new(5).unwrap();
+    let b: u8 = a;
+
+    let a = NonZero::new(5).unwrap();
+    5_u8.bar(a);
+}

tests/ui/mismatched_types/non_zero_coerce_fail.rs

@@ -0,0 +1,31 @@
+use std::num::NonZero;
+
+trait Foo: Sized {
+    fn foo(&self) {}
+    fn bar(self) {}
+}
+
+impl Foo for u8 {}
+impl Foo for u16 {}
+
+fn foo(_: impl Foo) {}
+
+fn main() {
+    let x = NonZero::new(5_u8).unwrap();
+    x.foo();
+    //~^ ERROR: no method named `foo` found for struct `NonZero` in the current scope
+    x.bar();
+    //~^ ERROR: no method named `bar` found for struct `NonZero` in the current scope
+    foo(x);
+    //~^ ERROR: the trait bound `NonZero<u8>: Foo` is not satisfied
+    foo(x as _);
+
+    let a = NonZero::new(5).unwrap();
+    a.foo();
+    //~^ ERROR: no method named `foo` found for struct `NonZero` in the current scope
+    a.bar();
+    //~^ ERROR: no method named `bar` found for struct `NonZero` in the current scope
+    foo(a);
+    //~^ ERROR: the trait bound `NonZero<{integer}>: Foo` is not satisfied
+    foo(a as _);
+}

tests/ui/mismatched_types/non_zero_coerce_fail.stderr

@@ -0,0 +1,90 @@
+error[E0599]: no method named `foo` found for struct `NonZero` in the current scope
+  --> $DIR/non_zero_coerce_fail.rs:15:7
+   |
+LL |     x.foo();
+   |       ^^^ method not found in `NonZero<u8>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Foo` defines an item `foo`, perhaps you need to implement it
+  --> $DIR/non_zero_coerce_fail.rs:3:1
+   |
+LL | trait Foo: Sized {
+   | ^^^^^^^^^^^^^^^^
+
+error[E0599]: no method named `bar` found for struct `NonZero` in the current scope
+  --> $DIR/non_zero_coerce_fail.rs:17:7
+   |
+LL |     x.bar();
+   |       ^^^ method not found in `NonZero<u8>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Foo` defines an item `bar`, perhaps you need to implement it
+  --> $DIR/non_zero_coerce_fail.rs:3:1
+   |
+LL | trait Foo: Sized {
+   | ^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `NonZero<u8>: Foo` is not satisfied
+  --> $DIR/non_zero_coerce_fail.rs:19:9
+   |
+LL |     foo(x);
+   |     --- ^ the trait `Foo` is not implemented for `NonZero<u8>`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the following other types implement trait `Foo`:
+             u16
+             u8
+note: required by a bound in `foo`
+  --> $DIR/non_zero_coerce_fail.rs:11:16
+   |
+LL | fn foo(_: impl Foo) {}
+   |                ^^^ required by this bound in `foo`
+
+error[E0599]: no method named `foo` found for struct `NonZero` in the current scope
+  --> $DIR/non_zero_coerce_fail.rs:24:7
+   |
+LL |     a.foo();
+   |       ^^^ method not found in `NonZero<{integer}>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Foo` defines an item `foo`, perhaps you need to implement it
+  --> $DIR/non_zero_coerce_fail.rs:3:1
+   |
+LL | trait Foo: Sized {
+   | ^^^^^^^^^^^^^^^^
+
+error[E0599]: no method named `bar` found for struct `NonZero` in the current scope
+  --> $DIR/non_zero_coerce_fail.rs:26:7
+   |
+LL |     a.bar();
+   |       ^^^ method not found in `NonZero<{integer}>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Foo` defines an item `bar`, perhaps you need to implement it
+  --> $DIR/non_zero_coerce_fail.rs:3:1
+   |
+LL | trait Foo: Sized {
+   | ^^^^^^^^^^^^^^^^
+
+error[E0277]: the trait bound `NonZero<{integer}>: Foo` is not satisfied
+  --> $DIR/non_zero_coerce_fail.rs:28:9
+   |
+LL |     foo(a);
+   |     --- ^ the trait `Foo` is not implemented for `NonZero<{integer}>`
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the following other types implement trait `Foo`:
+             u16
+             u8
+note: required by a bound in `foo`
+  --> $DIR/non_zero_coerce_fail.rs:11:16
+   |
+LL | fn foo(_: impl Foo) {}
+   |                ^^^ required by this bound in `foo`
+
+error: aborting due to 6 previous errors
+
+Some errors have detailed explanations: E0277, E0599.
+For more information about an error, try `rustc --explain E0277`.

tests/ui/mismatched_types/non_zero_coerce_fail2.rs

@@ -0,0 +1,29 @@
+use std::num::NonZero;
+
+trait Foo<T>: Sized {
+    fn foo(&self, other: &T) {}
+    fn bar(self, other: T) {}
+}
+
+impl Foo<u8> for u8 {}
+impl Foo<u16> for u16 {}
+
+fn main() {
+    let x = NonZero::new(5_u8).unwrap();
+    5_u8.foo(&x);
+    //~^ ERROR: mismatched types
+    5_u8.bar(x);
+    5.foo(&x);
+    //~^ ERROR: the trait bound `{integer}: Foo<NonZero<u8>>` is not satisfied
+    5.bar(x);
+    //~^ ERROR: the trait bound `{integer}: Foo<NonZero<u8>>` is not satisfied
+
+    let a = NonZero::new(5).unwrap();
+    5_u8.foo(&a);
+    //~^ ERROR: mismatched types
+    5_u8.bar(a);
+    5.foo(&a);
+    //~^ ERROR: the trait bound `{integer}: Foo<NonZero<u8>>` is not satisfied
+    5.bar(a);
+    //~^ ERROR: the trait bound `{integer}: Foo<NonZero<u8>>` is not satisfied
+}