impl<'a, 'tcx> FnCtxt<'a, 'tcx> {                         }                     }                 }++                // Suggest using `add`, `offset` or `offset_from` for pointer - {integer},+                // pointer + {integer} or pointer - pointer.+                if op.span.can_be_used_for_suggestions() {+                    if op.node == hir::BinOpKind::Add {+                        match (lhs_ty.kind(), rhs_ty) {+                            (RawPtr(..), rhs_ty) if rhs_ty.is_integral() => {+                                let lhs_snip =+                                    self.tcx.sess.source_map().span_to_snippet(lhs_expr.span);+                                let rhs_snip =+                                    self.tcx.sess.source_map().span_to_snippet(rhs_expr.span);+                                if let Ok(lhs_snip) = lhs_snip && let Ok(rhs_snip) = rhs_snip {+                                    err.span_suggestion(+                                        expr.span,+                                        "consider using `wrapping_add` or `add` for pointer + {integer}",+                                        format!("{lhs_snip}.wrapping_add({rhs_snip})"),+                                        Applicability::MaybeIncorrect+                                    );+                                }+                            }+                            _ => {}+                        }+                    } else if op.node == hir::BinOpKind::Sub {+                        match (lhs_ty.kind(), rhs_ty) {+                            (RawPtr(..), rhs_ty) if rhs_ty.is_integral() => {+                                let lhs_snip =+                                    self.tcx.sess.source_map().span_to_snippet(lhs_expr.span);+                                let rhs_snip =+                                    self.tcx.sess.source_map().span_to_snippet(rhs_expr.span);+                                if let Ok(lhs_snip) = lhs_snip && let Ok(rhs_snip) = rhs_snip {+                                    err.span_suggestion(+                                        expr.span,+                                        "consider using `wrapping_sub` or `sub` for pointer - {integer}",+                                        format!("{lhs_snip}.wrapping_sub({rhs_snip})"),+                                        Applicability::MaybeIncorrect+                                    );+                                }+                            }+                            (RawPtr(..), rhs_ty) if rhs_ty.is_unsafe_ptr() => {+                                let lhs_snip =+                                    self.tcx.sess.source_map().span_to_snippet(lhs_expr.span);+                                let rhs_snip =+                                    self.tcx.sess.source_map().span_to_snippet(rhs_expr.span);+                                if let Ok(lhs_snip) = lhs_snip && let Ok(rhs_snip) = rhs_snip {+                                    err.span_suggestion(+                                        expr.span,+                                        "consider using `offset_from` for pointer - pointer",+                                        format!("unsafe {{ {lhs_snip}.offset_from({rhs_snip}) }}"),

 fn data_offset_align(align: usize) -> usize {     let layout = Layout::new::<RcBox<()>>();     layout.size() + layout.padding_needed_for(align) }++/// A uniquely owned `Rc`+///+/// This represents an `Rc` that is known to be uniquely owned -- that is, have exactly one strong+/// reference. Multiple weak pointers can be created, but attempts to upgrade those to strong+/// references will fail unless the `UniqueRc` they point to has been converted into a regular `Rc`.+///+/// Because they are uniquely owned, the contents of a `UniqueRc` can be freely mutated. A common+/// use case is to have an object be mutable during its initialization phase but then have it become+/// immutable and converted to a normal `Rc`.+///+/// This can be used as a flexible way to create cyclic data structures, as in the example below.+///+/// ```+/// #![feature(unique_rc_arc)]+/// use std::rc::{Rc, Weak, UniqueRc};+///+/// struct Gadget {+///     #[allow(dead_code)]+///     me: Weak<Gadget>,+/// }+///+/// fn create_gadget() -> Option<Rc<Gadget>> {+///     let mut rc = UniqueRc::new(Gadget {+///         me: Weak::new(),+///     });+///     rc.me = UniqueRc::downgrade(&rc);+///     Some(UniqueRc::into_rc(rc))+/// }+///+/// create_gadget().unwrap();+/// ```+///+/// An advantage of using `UniqueRc` over [`Rc::new_cyclic`] to build cyclic data structures is that+/// [`Rc::new_cyclic`]'s `data_fn` parameter cannot be async or return a [`Result`]. As shown in the+/// previous example, `UniqueRc` allows for more flexibility in the construction of cyclic data,+/// including fallible or async constructors.+#[unstable(feature = "unique_rc_arc", issue = "none")]+#[derive(Debug)]+pub struct UniqueRc<T> {+    ptr: NonNull<RcBox<T>>,+}++impl<T> UniqueRc<T> {+    /// Creates a new `UniqueRc`+    ///+    /// Weak references to this `UniqueRc` can be created with [`UniqueRc::weak`]. Upgrading these

 fn data_offset_align(align: usize) -> usize {     let layout = Layout::new::<RcBox<()>>();     layout.size() + layout.padding_needed_for(align) }++/// A uniquely owned `Rc`+///+/// This represents an `Rc` that is known to be uniquely owned -- that is, have exactly one strong+/// reference. Multiple weak pointers can be created, but attempts to upgrade those to strong+/// references will fail unless the `UniqueRc` they point to has been converted into a regular `Rc`.+///+/// Because they are uniquely owned, the contents of a `UniqueRc` can be freely mutated. A common+/// use case is to have an object be mutable during its initialization phase but then have it become+/// immutable and converted to a normal `Rc`.+///+/// This can be used as a flexible way to create cyclic data structures, as in the example below.+///+/// ```+/// #![feature(unique_rc_arc)]+/// use std::rc::{Rc, Weak, UniqueRc};+///+/// struct Gadget {+///     #[allow(dead_code)]+///     me: Weak<Gadget>,+/// }+///+/// fn create_gadget() -> Option<Rc<Gadget>> {+///     let mut rc = UniqueRc::new(Gadget {+///         me: Weak::new(),+///     });+///     rc.me = UniqueRc::downgrade(&rc);+///     Some(UniqueRc::into_rc(rc))+/// }+///+/// create_gadget().unwrap();+/// ```+///+/// An advantage of using `UniqueRc` over [`Rc::new_cyclic`] to build cyclic data structures is that+/// [`Rc::new_cyclic`]'s `data_fn` parameter cannot be async or return a [`Result`]. As shown in the+/// previous example, `UniqueRc` allows for more flexibility in the construction of cyclic data,+/// including fallible or async constructors.+#[unstable(feature = "unique_rc_arc", issue = "none")]+#[derive(Debug)]+pub struct UniqueRc<T> {+    ptr: NonNull<RcBox<T>>,+}++impl<T> UniqueRc<T> {+    /// Creates a new `UniqueRc`+    ///+    /// Weak references to this `UniqueRc` can be created with [`UniqueRc::weak`]. Upgrading these+    /// weak references will fail before the `UniqueRc` has been converted into an [`Rc`]. After+    /// converting the `UniqueRc` into an [`Rc`], any weak references created beforehand will point+    /// to the new [`Rc`].+    #[unstable(feature = "unique_rc_arc", issue = "none")]+    pub fn new(value: T) -> Self {+        Self {+            ptr: Box::leak(Box::new(RcBox {+                strong: Cell::new(0),+                // keep one weak reference so if all the weak pointers that are created are dropped+                // the UniqueRc still stays valid.+                weak: Cell::new(1),+                value,+            }))+            .into(),+        }+    }++    /// Creates a new weak reference to the `UniqueRc`+    ///+    /// Attempting to upgrade this weak reference will fail before the `UniqueRc` has been converted+    /// to a [`Rc`] using [`UniqueRc::into_rc`].+    #[unstable(feature = "unique_rc_arc", issue = "none")]+    pub fn downgrade(this: &Self) -> Weak<T> {+        // SAFETY: This pointer was allocated at creation time and we guarantee that we only have+        // one strong reference before converting to a regular Rc.+        unsafe {+            this.ptr.as_ref().inc_weak();+        }+        Weak { ptr: this.ptr }+    }++    /// Converts the `UniqueRc` into a regular [`Rc`]+    ///+    /// This consumes the `UniqueRc` and returns a regular [`Rc`] that contains the `value` that+    /// is passed to `into_rc`.+    ///+    /// Any weak references created before this method is called can now be upgraded to strong+    /// references.+    #[unstable(feature = "unique_rc_arc", issue = "none")]+    pub fn into_rc(this: Self) -> Rc<T> {+        let mut this = ManuallyDrop::new(this);+        // SAFETY: This pointer was allocated at creation time so we know it is valid.+        unsafe {+            // Convert our weak reference into a strong reference+            this.ptr.as_mut().strong.set(1);+            Rc::from_inner(this.ptr)+        }+    }+}++#[unstable(feature = "unique_rc_arc", issue = "none")]+impl<T> Deref for UniqueRc<T> {+    type Target = T;++    fn deref(&self) -> &T {+        // SAFETY: This pointer was allocated at creation time so we know it is valid.+        unsafe { &self.ptr.as_ref().value }+    }+}++#[unstable(feature = "unique_rc_arc", issue = "none")]+impl<T> DerefMut for UniqueRc<T> {+    fn deref_mut(&mut self) -> &mut T {+        // SAFETY: This pointer was allocated at creation time so we know it is valid. We know we+        // have unique ownership and therefore it's safe to make a mutable reference because+        // `UniqueRc` owns the only strong reference to itself.+        unsafe { &mut self.ptr.as_mut().value }+    }+}++#[unstable(feature = "unique_rc_arc", issue = "none")]+impl<T> Drop for UniqueRc<T> {+    fn drop(&mut self) {+        // We want to make sure the pretend weak reference we're holding gets dropped, so convert+        // ourselves into an actual Weak reference and let its destructor take over.+        Weak { ptr: self.ptr };

 fn data_offset_align(align: usize) -> usize {     let layout = Layout::new::<RcBox<()>>();     layout.size() + layout.padding_needed_for(align) }++/// A uniquely owned `Rc`+///+/// This represents an `Rc` that is known to be uniquely owned -- that is, have exactly one strong+/// reference. Multiple weak pointers can be created, but attempts to upgrade those to strong+/// references will fail unless the `UniqueRc` they point to has been converted into a regular `Rc`.+///+/// Because they are uniquely owned, the contents of a `UniqueRc` can be freely mutated. A common+/// use case is to have an object be mutable during its initialization phase but then have it become+/// immutable and converted to a normal `Rc`.+///+/// This can be used as a flexible way to create cyclic data structures, as in the example below.+///+/// ```+/// #![feature(unique_rc_arc)]+/// use std::rc::{Rc, Weak, UniqueRc};+///+/// struct Gadget {+///     #[allow(dead_code)]+///     me: Weak<Gadget>,+/// }+///+/// fn create_gadget() -> Option<Rc<Gadget>> {+///     let mut rc = UniqueRc::new(Gadget {+///         me: Weak::new(),+///     });+///     rc.me = UniqueRc::downgrade(&rc);+///     Some(UniqueRc::into_rc(rc))+/// }+///+/// create_gadget().unwrap();+/// ```+///+/// An advantage of using `UniqueRc` over [`Rc::new_cyclic`] to build cyclic data structures is that+/// [`Rc::new_cyclic`]'s `data_fn` parameter cannot be async or return a [`Result`]. As shown in the+/// previous example, `UniqueRc` allows for more flexibility in the construction of cyclic data,+/// including fallible or async constructors.+#[unstable(feature = "unique_rc_arc", issue = "none")]+#[derive(Debug)]+pub struct UniqueRc<T> {+    ptr: NonNull<RcBox<T>>,+}++impl<T> UniqueRc<T> {+    /// Creates a new `UniqueRc`+    ///+    /// Weak references to this `UniqueRc` can be created with [`UniqueRc::weak`]. Upgrading these+    /// weak references will fail before the `UniqueRc` has been converted into an [`Rc`]. After+    /// converting the `UniqueRc` into an [`Rc`], any weak references created beforehand will point+    /// to the new [`Rc`].+    #[unstable(feature = "unique_rc_arc", issue = "none")]+    pub fn new(value: T) -> Self {+        Self {+            ptr: Box::leak(Box::new(RcBox {+                strong: Cell::new(0),+                // keep one weak reference so if all the weak pointers that are created are dropped+                // the UniqueRc still stays valid.+                weak: Cell::new(1),+                value,+            }))+            .into(),+        }+    }++    /// Creates a new weak reference to the `UniqueRc`+    ///+    /// Attempting to upgrade this weak reference will fail before the `UniqueRc` has been converted+    /// to a [`Rc`] using [`UniqueRc::into_rc`].+    #[unstable(feature = "unique_rc_arc", issue = "none")]+    pub fn downgrade(this: &Self) -> Weak<T> {+        // SAFETY: This pointer was allocated at creation time and we guarantee that we only have+        // one strong reference before converting to a regular Rc.+        unsafe {+            this.ptr.as_ref().inc_weak();+        }+        Weak { ptr: this.ptr }+    }++    /// Converts the `UniqueRc` into a regular [`Rc`]+    ///+    /// This consumes the `UniqueRc` and returns a regular [`Rc`] that contains the `value` that+    /// is passed to `into_rc`.+    ///+    /// Any weak references created before this method is called can now be upgraded to strong+    /// references.+    #[unstable(feature = "unique_rc_arc", issue = "none")]+    pub fn into_rc(this: Self) -> Rc<T> {+        let mut this = ManuallyDrop::new(this);+        // SAFETY: This pointer was allocated at creation time so we know it is valid.+        unsafe {+            // Convert our weak reference into a strong reference+            this.ptr.as_mut().strong.set(1);+            Rc::from_inner(this.ptr)+        }+    }+}++#[unstable(feature = "unique_rc_arc", issue = "none")]+impl<T> Deref for UniqueRc<T> {+    type Target = T;++    fn deref(&self) -> &T {+        // SAFETY: This pointer was allocated at creation time so we know it is valid.+        unsafe { &self.ptr.as_ref().value }+    }+}++#[unstable(feature = "unique_rc_arc", issue = "none")]+impl<T> DerefMut for UniqueRc<T> {+    fn deref_mut(&mut self) -> &mut T {+        // SAFETY: This pointer was allocated at creation time so we know it is valid. We know we+        // have unique ownership and therefore it's safe to make a mutable reference because+        // `UniqueRc` owns the only strong reference to itself.+        unsafe { &mut self.ptr.as_mut().value }

 impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> {                         // to borrow discr.                         needs_to_be_read = true;                     }+                    PatKind::Slice(&[], Some(_), &[]) if !discr_place.place.base_ty.is_array() => {+                        // If the pattern is a wildcard only, we don't need to read the length+                    }+                    PatKind::Slice(..) if !discr_place.place.base_ty.is_array() => {+                        needs_to_be_read = true;+                    }                     PatKind::Or(_)                     | PatKind::Box(_)                     | PatKind::Slice(..)