diff --git a/Cargo.lock b/Cargo.lock
index 890c5ce3ac478..197b2c8f3f06a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1879,9 +1879,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
[[package]]
name = "libc"
-version = "0.2.99"
+version = "0.2.103"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765"
+checksum = "dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"
dependencies = [
"rustc-std-workspace-core",
]
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
index d05cfebc5f02e..11cdbe84accb7 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
@@ -498,6 +498,27 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
diag.span_label(*span, format!("`{}` escapes the {} body here", fr_name, escapes_from));
}
+ // Only show an extra note if we can find an 'error region' for both of the region
+ // variables. This avoids showing a noisy note that just mentions 'synthetic' regions
+ // that don't help the user understand the error.
+ if self.to_error_region(errci.fr).is_some()
+ && self.to_error_region(errci.outlived_fr).is_some()
+ {
+ let fr_region_name = self.give_region_a_name(errci.fr).unwrap();
+ fr_region_name.highlight_region_name(&mut diag);
+ let outlived_fr_region_name = self.give_region_a_name(errci.outlived_fr).unwrap();
+ outlived_fr_region_name.highlight_region_name(&mut diag);
+
+ diag.span_label(
+ *span,
+ format!(
+ "{}requires that `{}` must outlive `{}`",
+ category.description(),
+ fr_region_name,
+ outlived_fr_region_name,
+ ),
+ );
+ }
diag
}
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index f13531814d6eb..fee13fd2e2eaf 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -1826,8 +1826,11 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
match layout.variants {
Variants::Single { index } => {
- debug!("print-type-size `{:#?}` variant {}", layout, adt_def.variants[index].ident);
- if !adt_def.variants.is_empty() {
+ if !adt_def.variants.is_empty() && layout.fields != FieldsShape::Primitive {
+ debug!(
+ "print-type-size `{:#?}` variant {}",
+ layout, adt_def.variants[index].ident
+ );
let variant_def = &adt_def.variants[index];
let fields: Vec<_> = variant_def.fields.iter().map(|f| f.ident.name).collect();
record(
diff --git a/compiler/rustc_typeck/src/check/cast.rs b/compiler/rustc_typeck/src/check/cast.rs
index 9736a7b2e28e3..51c766fe57c10 100644
--- a/compiler/rustc_typeck/src/check/cast.rs
+++ b/compiler/rustc_typeck/src/check/cast.rs
@@ -351,7 +351,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
);
let mut sugg = None;
let mut sugg_mutref = false;
- if let ty::Ref(reg, _, mutbl) = *self.cast_ty.kind() {
+ if let ty::Ref(reg, cast_ty, mutbl) = *self.cast_ty.kind() {
if let ty::RawPtr(TypeAndMut { ty: expr_ty, .. }) = *self.expr_ty.kind() {
if fcx
.try_coerce(
@@ -366,7 +366,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
)
.is_ok()
{
- sugg = Some(format!("&{}*", mutbl.prefix_str()));
+ sugg = Some((format!("&{}*", mutbl.prefix_str()), cast_ty == expr_ty));
}
} else if let ty::Ref(expr_reg, expr_ty, expr_mutbl) = *self.expr_ty.kind() {
if expr_mutbl == Mutability::Not
@@ -400,7 +400,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
)
.is_ok()
{
- sugg = Some(format!("&{}", mutbl.prefix_str()));
+ sugg = Some((format!("&{}", mutbl.prefix_str()), false));
}
} else if let ty::RawPtr(TypeAndMut { mutbl, .. }) = *self.cast_ty.kind() {
if fcx
@@ -416,19 +416,47 @@ impl<'a, 'tcx> CastCheck<'tcx> {
)
.is_ok()
{
- sugg = Some(format!("&{}", mutbl.prefix_str()));
+ sugg = Some((format!("&{}", mutbl.prefix_str()), false));
}
}
if sugg_mutref {
err.span_label(self.span, "invalid cast");
err.span_note(self.expr.span, "this reference is immutable");
err.span_note(self.cast_span, "trying to cast to a mutable reference type");
- } else if let Some(sugg) = sugg {
+ } else if let Some((sugg, remove_cast)) = sugg {
err.span_label(self.span, "invalid cast");
- err.span_suggestion_verbose(
- self.expr.span.shrink_to_lo(),
+
+ let has_parens = fcx
+ .tcx
+ .sess
+ .source_map()
+ .span_to_snippet(self.expr.span)
+ .map_or(false, |snip| snip.starts_with("("));
+
+ // Very crude check to see whether the expression must be wrapped
+ // in parentheses for the suggestion to work (issue #89497).
+ // Can/should be extended in the future.
+ let needs_parens = !has_parens
+ && match self.expr.kind {
+ hir::ExprKind::Cast(..) => true,
+ _ => false,
+ };
+
+ let mut suggestion = vec![(self.expr.span.shrink_to_lo(), sugg)];
+ if needs_parens {
+ suggestion[0].1 += "(";
+ suggestion.push((self.expr.span.shrink_to_hi(), ")".to_string()));
+ }
+ if remove_cast {
+ suggestion.push((
+ self.expr.span.shrink_to_hi().to(self.cast_span),
+ String::new(),
+ ));
+ }
+
+ err.multipart_suggestion_verbose(
"consider borrowing the value",
- sugg,
+ suggestion,
Applicability::MachineApplicable,
);
} else if !matches!(
diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs
index dfa0227dea3b8..05f94da6de70d 100644
--- a/library/alloc/src/collections/vec_deque/drain.rs
+++ b/library/alloc/src/collections/vec_deque/drain.rs
@@ -18,10 +18,21 @@ pub struct Drain<
T: 'a,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
> {
- pub(crate) after_tail: usize,
- pub(crate) after_head: usize,
- pub(crate) iter: Iter<'a, T>,
- pub(crate) deque: NonNull<VecDeque<T, A>>,
+ after_tail: usize,
+ after_head: usize,
+ iter: Iter<'a, T>,
+ deque: NonNull<VecDeque<T, A>>,
+}
+
+impl<'a, T, A: Allocator> Drain<'a, T, A> {
+ pub(super) unsafe fn new(
+ after_tail: usize,
+ after_head: usize,
+ iter: Iter<'a, T>,
+ deque: NonNull<VecDeque<T, A>>,
+ ) -> Self {
+ Drain { after_tail, after_head, iter, deque }
+ }
}
#[stable(feature = "collection_debug", since = "1.17.0")]
diff --git a/library/alloc/src/collections/vec_deque/iter_mut.rs b/library/alloc/src/collections/vec_deque/iter_mut.rs
index 7700b31cf5b46..31e6e3b06af5f 100644
--- a/library/alloc/src/collections/vec_deque/iter_mut.rs
+++ b/library/alloc/src/collections/vec_deque/iter_mut.rs
@@ -13,10 +13,21 @@ use super::{count, wrap_index, RingSlices};
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IterMut<'a, T: 'a> {
// Internal safety invariant: the entire slice is dereferencable.
- pub(crate) ring: *mut [T],
- pub(crate) tail: usize,
- pub(crate) head: usize,
- pub(crate) phantom: PhantomData<&'a mut [T]>,
+ ring: *mut [T],
+ tail: usize,
+ head: usize,
+ phantom: PhantomData<&'a mut [T]>,
+}
+
+impl<'a, T> IterMut<'a, T> {
+ pub(super) unsafe fn new(
+ ring: *mut [T],
+ tail: usize,
+ head: usize,
+ phantom: PhantomData<&'a mut [T]>,
+ ) -> Self {
+ IterMut { ring, tail, head, phantom }
+ }
}
// SAFETY: we do nothing thread-local and there is no interior mutability,
diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index f4de2b2ebe5dc..e996784bbad28 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -1000,12 +1000,9 @@ impl<T, A: Allocator> VecDeque<T, A> {
pub fn iter_mut(&mut self) -> IterMut<'_, T> {
// SAFETY: The internal `IterMut` safety invariant is established because the
// `ring` we create is a dereferencable slice for lifetime '_.
- IterMut {
- tail: self.tail,
- head: self.head,
- ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()),
- phantom: PhantomData,
- }
+ let ring = ptr::slice_from_raw_parts_mut(self.ptr(), self.cap());
+
+ unsafe { IterMut::new(ring, self.tail, self.head, PhantomData) }
}
/// Returns a pair of slices which contain, in order, the contents of the
@@ -1192,12 +1189,9 @@ impl<T, A: Allocator> VecDeque<T, A> {
// SAFETY: The internal `IterMut` safety invariant is established because the
// `ring` we create is a dereferencable slice for lifetime '_.
- IterMut {
- tail,
- head,
- ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()),
- phantom: PhantomData,
- }
+ let ring = ptr::slice_from_raw_parts_mut(self.ptr(), self.cap());
+
+ unsafe { IterMut::new(ring, tail, head, PhantomData) }
}
/// Creates a draining iterator that removes the specified range in the
@@ -1269,19 +1263,17 @@ impl<T, A: Allocator> VecDeque<T, A> {
// the drain is complete and the Drain destructor is run.
self.head = drain_tail;
- Drain {
- deque: NonNull::from(&mut *self),
- after_tail: drain_head,
- after_head: head,
- iter: Iter {
- tail: drain_tail,
- head: drain_head,
- // Crucially, we only create shared references from `self` here and read from
- // it. We do not write to `self` nor reborrow to a mutable reference.
- // Hence the raw pointer we created above, for `deque`, remains valid.
- ring: unsafe { self.buffer_as_slice() },
- },
- }
+ let deque = NonNull::from(&mut *self);
+ let iter = Iter {
+ tail: drain_tail,
+ head: drain_head,
+ // Crucially, we only create shared references from `self` here and read from
+ // it. We do not write to `self` nor reborrow to a mutable reference.
+ // Hence the raw pointer we created above, for `deque`, remains valid.
+ ring: unsafe { self.buffer_as_slice() },
+ };
+
+ unsafe { Drain::new(drain_head, head, iter, deque) }
}
/// Clears the `VecDeque`, removing all values.
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 4742970f9542b..f9d517ce8c0eb 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -142,6 +142,7 @@
#![feature(link_llvm_intrinsics)]
#![feature(llvm_asm)]
#![feature(min_specialization)]
+#![feature(mixed_integer_ops)]
#![cfg_attr(not(bootstrap), feature(must_not_suspend))]
#![feature(negative_impls)]
#![feature(never_type)]
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 9d46948ce02af..12dda61400f2a 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -433,6 +433,28 @@ macro_rules! int_impl {
unsafe { intrinsics::unchecked_add(self, rhs) }
}
+ /// Checked addition with an unsigned integer. Computes `self + rhs`,
+ /// returning `None` if overflow occurred.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_add_unsigned(2), Some(3));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add_unsigned(3), None);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_add_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
+ let (a, b) = self.overflowing_add_unsigned(rhs);
+ if unlikely!(b) {None} else {Some(a)}
+ }
+
/// Checked integer subtraction. Computes `self - rhs`, returning `None` if
/// overflow occurred.
///
@@ -479,6 +501,28 @@ macro_rules! int_impl {
unsafe { intrinsics::unchecked_sub(self, rhs) }
}
+ /// Checked subtraction with an unsigned integer. Computes `self - rhs`,
+ /// returning `None` if overflow occurred.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_sub_unsigned(2), Some(-1));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 2).checked_sub_unsigned(3), None);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_sub_unsigned(self, rhs: $UnsignedT) -> Option<Self> {
+ let (a, b) = self.overflowing_sub_unsigned(rhs);
+ if unlikely!(b) {None} else {Some(a)}
+ }
+
/// Checked integer multiplication. Computes `self * rhs`, returning `None` if
/// overflow occurred.
///
@@ -826,6 +870,32 @@ macro_rules! int_impl {
intrinsics::saturating_add(self, rhs)
}
+ /// Saturating addition with an unsigned integer. Computes `self + rhs`,
+ /// saturating at the numeric bounds instead of overflowing.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".saturating_add_unsigned(2), 3);")]
+ #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.saturating_add_unsigned(100), ", stringify!($SelfT), "::MAX);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn saturating_add_unsigned(self, rhs: $UnsignedT) -> Self {
+ // Overflow can only happen at the upper bound
+ // We cannot use `unwrap_or` here because it is not `const`
+ match self.checked_add_unsigned(rhs) {
+ Some(x) => x,
+ None => Self::MAX,
+ }
+ }
+
/// Saturating integer subtraction. Computes `self - rhs`, saturating at the
/// numeric bounds instead of overflowing.
///
@@ -847,6 +917,32 @@ macro_rules! int_impl {
intrinsics::saturating_sub(self, rhs)
}
+ /// Saturating subtraction with an unsigned integer. Computes `self - rhs`,
+ /// saturating at the numeric bounds instead of overflowing.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".saturating_sub_unsigned(127), -27);")]
+ #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.saturating_sub_unsigned(100), ", stringify!($SelfT), "::MIN);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn saturating_sub_unsigned(self, rhs: $UnsignedT) -> Self {
+ // Overflow can only happen at the lower bound
+ // We cannot use `unwrap_or` here because it is not `const`
+ match self.checked_sub_unsigned(rhs) {
+ Some(x) => x,
+ None => Self::MIN,
+ }
+ }
+
/// Saturating integer negation. Computes `-self`, returning `MAX` if `self == MIN`
/// instead of overflowing.
///
@@ -1002,6 +1098,27 @@ macro_rules! int_impl {
intrinsics::wrapping_add(self, rhs)
}
+ /// Wrapping (modular) addition with an unsigned integer. Computes
+ /// `self + rhs`, wrapping around at the boundary of the type.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(100", stringify!($SelfT), ".wrapping_add_unsigned(27), 127);")]
+ #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MAX.wrapping_add_unsigned(2), ", stringify!($SelfT), "::MIN + 1);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline(always)]
+ pub const fn wrapping_add_unsigned(self, rhs: $UnsignedT) -> Self {
+ self.wrapping_add(rhs as Self)
+ }
+
/// Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around at the
/// boundary of the type.
///
@@ -1022,6 +1139,27 @@ macro_rules! int_impl {
intrinsics::wrapping_sub(self, rhs)
}
+ /// Wrapping (modular) subtraction with an unsigned integer. Computes
+ /// `self - rhs`, wrapping around at the boundary of the type.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".wrapping_sub_unsigned(127), -127);")]
+ #[doc = concat!("assert_eq!((-2", stringify!($SelfT), ").wrapping_sub_unsigned(", stringify!($UnsignedT), "::MAX), -1);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline(always)]
+ pub const fn wrapping_sub_unsigned(self, rhs: $UnsignedT) -> Self {
+ self.wrapping_sub(rhs as Self)
+ }
+
/// Wrapping (modular) multiplication. Computes `self * rhs`, wrapping around at
/// the boundary of the type.
///
@@ -1372,6 +1510,33 @@ macro_rules! int_impl {
(sum as $SelfT, carry)
}
+ /// Calculates `self` + `rhs` with an unsigned `rhs`
+ ///
+ /// Returns a tuple of the addition along with a boolean indicating
+ /// whether an arithmetic overflow would occur. If an overflow would
+ /// have occurred then the wrapped value is returned.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".overflowing_add_unsigned(2), (3, false));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN).overflowing_add_unsigned(", stringify!($UnsignedT), "::MAX), (", stringify!($SelfT), "::MAX, false));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).overflowing_add_unsigned(3), (", stringify!($SelfT), "::MIN, true));")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn overflowing_add_unsigned(self, rhs: $UnsignedT) -> (Self, bool) {
+ let rhs = rhs as Self;
+ let (res, overflowed) = self.overflowing_add(rhs);
+ (res, overflowed ^ (rhs < 0))
+ }
+
/// Calculates `self` - `rhs`
///
/// Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow
@@ -1423,6 +1588,33 @@ macro_rules! int_impl {
(sum as $SelfT, borrow)
}
+ /// Calculates `self` - `rhs` with an unsigned `rhs`
+ ///
+ /// Returns a tuple of the subtraction along with a boolean indicating
+ /// whether an arithmetic overflow would occur. If an overflow would
+ /// have occurred then the wrapped value is returned.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".overflowing_sub_unsigned(2), (-1, false));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX).overflowing_sub_unsigned(", stringify!($UnsignedT), "::MAX), (", stringify!($SelfT), "::MIN, false));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MIN + 2).overflowing_sub_unsigned(3), (", stringify!($SelfT), "::MAX, true));")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn overflowing_sub_unsigned(self, rhs: $UnsignedT) -> (Self, bool) {
+ let rhs = rhs as Self;
+ let (res, overflowed) = self.overflowing_sub(rhs);
+ (res, overflowed ^ (rhs < 0))
+ }
+
/// Calculates the multiplication of `self` and `rhs`.
///
/// Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow
diff --git a/library/core/src/num/mod.rs b/library/core/src/num/mod.rs
index 59b68cbe9c0ce..d5fb98eff575d 100644
--- a/library/core/src/num/mod.rs
+++ b/library/core/src/num/mod.rs
@@ -245,7 +245,7 @@ const ASCII_CASE_MASK: u8 = 0b0010_0000;
#[lang = "u8"]
impl u8 {
widening_impl! { u8, u16, 8 }
- uint_impl! { u8, u8, 8, 255, 2, "0x82", "0xa", "0x12", "0x12", "0x48", "[0x12]",
+ uint_impl! { u8, u8, i8, 8, 255, 2, "0x82", "0xa", "0x12", "0x12", "0x48", "[0x12]",
"[0x12]", "", "" }
/// Checks if the value is within the ASCII range.
@@ -779,21 +779,21 @@ impl u8 {
#[lang = "u16"]
impl u16 {
widening_impl! { u16, u32, 16 }
- uint_impl! { u16, u16, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
+ uint_impl! { u16, u16, i16, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
"[0x34, 0x12]", "[0x12, 0x34]", "", "" }
}
#[lang = "u32"]
impl u32 {
widening_impl! { u32, u64, 32 }
- uint_impl! { u32, u32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
+ uint_impl! { u32, u32, i32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
"0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]", "", "" }
}
#[lang = "u64"]
impl u64 {
widening_impl! { u64, u128, 64 }
- uint_impl! { u64, u64, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
+ uint_impl! { u64, u64, i64, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
"0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48",
"[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]",
"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]",
@@ -802,7 +802,7 @@ impl u64 {
#[lang = "u128"]
impl u128 {
- uint_impl! { u128, u128, 128, 340282366920938463463374607431768211455, 16,
+ uint_impl! { u128, u128, i128, 128, 340282366920938463463374607431768211455, 16,
"0x13f40000000000000000000000004f76", "0x4f7613f4", "0x12345678901234567890123456789012",
"0x12907856341290785634129078563412", "0x48091e6a2c48091e6a2c48091e6a2c48",
"[0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, \
@@ -816,7 +816,7 @@ impl u128 {
#[lang = "usize"]
impl usize {
widening_impl! { usize, u32, 16 }
- uint_impl! { usize, u16, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
+ uint_impl! { usize, u16, isize, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
"[0x34, 0x12]", "[0x12, 0x34]",
usize_isize_to_xe_bytes_doc!(), usize_isize_from_xe_bytes_doc!() }
}
@@ -824,7 +824,7 @@ impl usize {
#[lang = "usize"]
impl usize {
widening_impl! { usize, u64, 32 }
- uint_impl! { usize, u32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
+ uint_impl! { usize, u32, isize, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
"0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]",
usize_isize_to_xe_bytes_doc!(), usize_isize_from_xe_bytes_doc!() }
}
@@ -833,7 +833,7 @@ impl usize {
#[lang = "usize"]
impl usize {
widening_impl! { usize, u128, 64 }
- uint_impl! { usize, u64, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
+ uint_impl! { usize, u64, isize, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
"0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48",
"[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]",
"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]",
@@ -865,23 +865,41 @@ impl usize {
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
#[stable(feature = "rust1", since = "1.0.0")]
pub enum FpCategory {
- /// "Not a Number", often obtained by dividing by zero.
+ /// NaN (not a number): this value results from calculations like `(-1.0).sqrt()`.
+ ///
+ /// See [the documentation for `f32`](f32) for more information on the unusual properties
+ /// of NaN.
#[stable(feature = "rust1", since = "1.0.0")]
Nan,
- /// Positive or negative infinity.
+ /// Positive or negative infinity, which often results from dividing a nonzero number
+ /// by zero.
#[stable(feature = "rust1", since = "1.0.0")]
Infinite,
/// Positive or negative zero.
+ ///
+ /// See [the documentation for `f32`](f32) for more information on the signedness of zeroes.
#[stable(feature = "rust1", since = "1.0.0")]
Zero,
- /// De-normalized floating point representation (less precise than `Normal`).
+ /// “Subnormal” or “denormal” floating point representation (less precise, relative to
+ /// their magnitude, than [`Normal`]).
+ ///
+ /// Subnormal numbers are larger in magnitude than [`Zero`] but smaller in magnitude than all
+ /// [`Normal`] numbers.
+ ///
+ /// [`Normal`]: Self::Normal
+ /// [`Zero`]: Self::Zero
#[stable(feature = "rust1", since = "1.0.0")]
Subnormal,
- /// A regular floating point number.
+ /// A regular floating point number, not any of the exceptional categories.
+ ///
+ /// The smallest positive normal numbers are [`f32::MIN_POSITIVE`] and [`f64::MIN_POSITIVE`],
+ /// and the largest positive normal numbers are [`f32::MAX`] and [`f64::MAX`]. (Unlike signed
+ /// integers, floating point numbers are symmetric in their range, so negating any of these
+ /// constants will produce their negative counterpart.)
#[stable(feature = "rust1", since = "1.0.0")]
Normal,
}
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 7ef8ea23b5028..25cd582bb67d7 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1,5 +1,5 @@
macro_rules! uint_impl {
- ($SelfT:ty, $ActualT:ident, $BITS:expr, $MaxV:expr,
+ ($SelfT:ty, $ActualT:ident, $SignedT:ident, $BITS:expr, $MaxV:expr,
$rot:expr, $rot_op:expr, $rot_result:expr, $swap_op:expr, $swapped:expr,
$reversed:expr, $le_bytes:expr, $be_bytes:expr,
$to_xe_bytes_doc:expr, $from_xe_bytes_doc:expr) => {
@@ -442,6 +442,29 @@ macro_rules! uint_impl {
unsafe { intrinsics::unchecked_add(self, rhs) }
}
+ /// Checked addition with a signed integer. Computes `self + rhs`,
+ /// returning `None` if overflow occurred.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_add_signed(2), Some(3));")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".checked_add_signed(-2), None);")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).checked_add_signed(3), None);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_add_signed(self, rhs: $SignedT) -> Option<Self> {
+ let (a, b) = self.overflowing_add_signed(rhs);
+ if unlikely!(b) {None} else {Some(a)}
+ }
+
/// Checked integer subtraction. Computes `self - rhs`, returning
/// `None` if overflow occurred.
///
@@ -995,6 +1018,35 @@ macro_rules! uint_impl {
intrinsics::saturating_add(self, rhs)
}
+ /// Saturating addition with a signed integer. Computes `self + rhs`,
+ /// saturating at the numeric bounds instead of overflowing.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".saturating_add_signed(2), 3);")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".saturating_add_signed(-2), 0);")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).saturating_add_signed(4), ", stringify!($SelfT), "::MAX);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn saturating_add_signed(self, rhs: $SignedT) -> Self {
+ let (res, overflow) = self.overflowing_add(rhs as Self);
+ if overflow == (rhs < 0) {
+ res
+ } else if overflow {
+ Self::MAX
+ } else {
+ 0
+ }
+ }
+
/// Saturating integer subtraction. Computes `self - rhs`, saturating
/// at the numeric bounds instead of overflowing.
///
@@ -1111,6 +1163,28 @@ macro_rules! uint_impl {
intrinsics::wrapping_add(self, rhs)
}
+ /// Wrapping (modular) addition with a signed integer. Computes
+ /// `self + rhs`, wrapping around at the boundary of the type.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".wrapping_add_signed(2), 3);")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".wrapping_add_signed(-2), ", stringify!($SelfT), "::MAX);")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).wrapping_add_signed(4), 1);")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn wrapping_add_signed(self, rhs: $SignedT) -> Self {
+ self.wrapping_add(rhs as Self)
+ }
+
/// Wrapping (modular) subtraction. Computes `self - rhs`,
/// wrapping around at the boundary of the type.
///
@@ -1435,6 +1509,32 @@ macro_rules! uint_impl {
(c, b | d)
}
+ /// Calculates `self` + `rhs` with a signed `rhs`
+ ///
+ /// Returns a tuple of the addition along with a boolean indicating
+ /// whether an arithmetic overflow would occur. If an overflow would
+ /// have occurred then the wrapped value is returned.
+ ///
+ /// # Examples
+ ///
+ /// Basic usage:
+ ///
+ /// ```
+ /// # #![feature(mixed_integer_ops)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".overflowing_add_signed(2), (3, false));")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT), ".overflowing_add_signed(-2), (", stringify!($SelfT), "::MAX, true));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT), "::MAX - 2).overflowing_add_signed(4), (1, true));")]
+ /// ```
+ #[unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[rustc_const_unstable(feature = "mixed_integer_ops", issue = "87840")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn overflowing_add_signed(self, rhs: $SignedT) -> (Self, bool) {
+ let (res, overflowed) = self.overflowing_add(rhs as Self);
+ (res, overflowed ^ (rhs < 0))
+ }
+
/// Calculates `self` - `rhs`
///
/// Returns a tuple of the subtraction along with a boolean indicating
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 2b77dc54ab35c..6bc445c6f2b07 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -15,7 +15,7 @@ cfg-if = { version = "0.1.8", features = ['rustc-dep-of-std'] }
panic_unwind = { path = "../panic_unwind", optional = true }
panic_abort = { path = "../panic_abort" }
core = { path = "../core" }
-libc = { version = "0.2.99", default-features = false, features = ['rustc-dep-of-std'] }
+libc = { version = "0.2.103", default-features = false, features = ['rustc-dep-of-std'] }
compiler_builtins = { version = "0.1.44" }
profiler_builtins = { path = "../profiler_builtins", optional = true }
unwind = { path = "../unwind" }
diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs
index 25cc5e67ad14e..980b2531192e8 100644
--- a/library/std/src/io/cursor.rs
+++ b/library/std/src/io/cursor.rs
@@ -292,12 +292,7 @@ where
SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
SeekFrom::Current(n) => (self.pos, n),
};
- let new_pos = if offset >= 0 {
- base_pos.checked_add(offset as u64)
- } else {
- base_pos.checked_sub((offset.wrapping_neg()) as u64)
- };
- match new_pos {
+ match base_pos.checked_add_signed(offset) {
Some(n) => {
self.pos = n;
Ok(self.pos)
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 0ba4e85886caa..a7516bf4ffd37 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -297,6 +297,7 @@
#![feature(maybe_uninit_slice)]
#![feature(maybe_uninit_uninit_array)]
#![feature(min_specialization)]
+#![feature(mixed_integer_ops)]
#![cfg_attr(not(bootstrap), feature(must_not_suspend))]
#![feature(needs_panic_runtime)]
#![feature(negative_impls)]
diff --git a/src/test/ui/async-await/issues/issue-62097.nll.stderr b/src/test/ui/async-await/issues/issue-62097.nll.stderr
index e71bcf5822808..786f621326049 100644
--- a/src/test/ui/async-await/issues/issue-62097.nll.stderr
+++ b/src/test/ui/async-await/issues/issue-62097.nll.stderr
@@ -20,9 +20,15 @@ error[E0521]: borrowed data escapes outside of associated function
--> $DIR/issue-62097.rs:13:9
|
LL | pub async fn run_dummy_fn(&self) {
- | ----- `self` is a reference that is only valid in the associated function body
+ | -----
+ | |
+ | `self` is a reference that is only valid in the associated function body
+ | let's call the lifetime of this reference `'1`
LL | foo(|| self.bar()).await;
- | ^^^^^^^^^^^^^^^^^^ `self` escapes the associated function body here
+ | ^^^^^^^^^^^^^^^^^^
+ | |
+ | `self` escapes the associated function body here
+ | argument requires that `'1` must outlive `'static`
error: aborting due to 2 previous errors
diff --git a/src/test/ui/cast/issue-89497.fixed b/src/test/ui/cast/issue-89497.fixed
new file mode 100644
index 0000000000000..04c10a5f79ed4
--- /dev/null
+++ b/src/test/ui/cast/issue-89497.fixed
@@ -0,0 +1,10 @@
+// Regression test for issue #89497.
+
+// run-rustfix
+
+fn main() {
+ let pointer: usize = &1_i32 as *const i32 as usize;
+ let _reference: &'static i32 = unsafe { &*(pointer as *const i32) };
+ //~^ ERROR: non-primitive cast
+ //~| HELP: consider borrowing the value
+}
diff --git a/src/test/ui/cast/issue-89497.rs b/src/test/ui/cast/issue-89497.rs
new file mode 100644
index 0000000000000..76301b704c81c
--- /dev/null
+++ b/src/test/ui/cast/issue-89497.rs
@@ -0,0 +1,10 @@
+// Regression test for issue #89497.
+
+// run-rustfix
+
+fn main() {
+ let pointer: usize = &1_i32 as *const i32 as usize;
+ let _reference: &'static i32 = unsafe { pointer as *const i32 as &'static i32 };
+ //~^ ERROR: non-primitive cast
+ //~| HELP: consider borrowing the value
+}
diff --git a/src/test/ui/cast/issue-89497.stderr b/src/test/ui/cast/issue-89497.stderr
new file mode 100644
index 0000000000000..3726f8a41015e
--- /dev/null
+++ b/src/test/ui/cast/issue-89497.stderr
@@ -0,0 +1,15 @@
+error[E0605]: non-primitive cast: `*const i32` as `&'static i32`
+ --> $DIR/issue-89497.rs:7:45
+ |
+LL | let _reference: &'static i32 = unsafe { pointer as *const i32 as &'static i32 };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ invalid cast
+ |
+help: consider borrowing the value
+ |
+LL - let _reference: &'static i32 = unsafe { pointer as *const i32 as &'static i32 };
+LL + let _reference: &'static i32 = unsafe { &*(pointer as *const i32) };
+ |
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0605`.
diff --git a/src/test/ui/const-generics/generic_const_exprs/const_eval_resolve_canonical.rs b/src/test/ui/const-generics/generic_const_exprs/const_eval_resolve_canonical.rs
new file mode 100644
index 0000000000000..b79bc262d2bac
--- /dev/null
+++ b/src/test/ui/const-generics/generic_const_exprs/const_eval_resolve_canonical.rs
@@ -0,0 +1,29 @@
+// run-pass
+#![feature(generic_const_exprs)]
+#![allow(incomplete_features)]
+
+trait Foo<const N: usize> {
+ type Assoc: Default;
+}
+
+impl Foo<0> for () {
+ type Assoc = u32;
+}
+
+impl Foo<3> for () {
+ type Assoc = i64;
+}
+
+fn foo<T, const N: usize>(_: T) -> <() as Foo<{ N + 1 }>>::Assoc
+where
+ (): Foo<{ N + 1 }>,
+{
+ Default::default()
+}
+
+fn main() {
+ // Test that we can correctly infer `T` which requires evaluating
+ // `{ N + 1 }` which has substs containing an inference var
+ let mut _q = Default::default();
+ _q = foo::<_, 2>(_q);
+}
diff --git a/src/test/ui/error-codes/E0605.stderr b/src/test/ui/error-codes/E0605.stderr
index e5647ee6d0968..d082b6c10cc2a 100644
--- a/src/test/ui/error-codes/E0605.stderr
+++ b/src/test/ui/error-codes/E0605.stderr
@@ -12,8 +12,9 @@ LL | v as &u8;
|
help: consider borrowing the value
|
-LL | &*v as &u8;
- | ++
+LL - v as &u8;
+LL + &*v;
+ |
error: aborting due to 2 previous errors
diff --git a/src/test/ui/impl-header-lifetime-elision/dyn-trait.nll.stderr b/src/test/ui/impl-header-lifetime-elision/dyn-trait.nll.stderr
index e49bd9da754d6..88c260b18cbb0 100644
--- a/src/test/ui/impl-header-lifetime-elision/dyn-trait.nll.stderr
+++ b/src/test/ui/impl-header-lifetime-elision/dyn-trait.nll.stderr
@@ -2,9 +2,14 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/dyn-trait.rs:20:5
|
LL | fn with_dyn_debug_static<'a>(x: Box<dyn Debug + 'a>) {
- | - `x` is a reference that is only valid in the function body
+ | -- - `x` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | static_val(x);
- | ^^^^^^^^^^^^^ `x` escapes the function body here
+ | ^^^^^^^^^^^^^
+ | |
+ | `x` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-16683.nll.stderr b/src/test/ui/issues/issue-16683.nll.stderr
index 51d86eaf9e60c..0e8f520353fba 100644
--- a/src/test/ui/issues/issue-16683.nll.stderr
+++ b/src/test/ui/issues/issue-16683.nll.stderr
@@ -1,10 +1,19 @@
error[E0521]: borrowed data escapes outside of associated function
--> $DIR/issue-16683.rs:4:9
|
+LL | trait T<'a> {
+ | -- lifetime `'a` defined here
+LL | fn a(&'a self) -> &'a bool;
LL | fn b(&self) {
- | ----- `self` is a reference that is only valid in the associated function body
+ | -----
+ | |
+ | `self` is a reference that is only valid in the associated function body
+ | let's call the lifetime of this reference `'1`
LL | self.a();
- | ^^^^^^^^ `self` escapes the associated function body here
+ | ^^^^^^^^
+ | |
+ | `self` escapes the associated function body here
+ | argument requires that `'1` must outlive `'a`
error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-17758.nll.stderr b/src/test/ui/issues/issue-17758.nll.stderr
index 075c141ed7af6..b929fdbf3687a 100644
--- a/src/test/ui/issues/issue-17758.nll.stderr
+++ b/src/test/ui/issues/issue-17758.nll.stderr
@@ -1,10 +1,19 @@
error[E0521]: borrowed data escapes outside of associated function
--> $DIR/issue-17758.rs:7:9
|
+LL | trait Foo<'a> {
+ | -- lifetime `'a` defined here
+LL | fn foo(&'a self);
LL | fn bar(&self) {
- | ----- `self` is a reference that is only valid in the associated function body
+ | -----
+ | |
+ | `self` is a reference that is only valid in the associated function body
+ | let's call the lifetime of this reference `'1`
LL | self.foo();
- | ^^^^^^^^^^ `self` escapes the associated function body here
+ | ^^^^^^^^^^
+ | |
+ | `self` escapes the associated function body here
+ | argument requires that `'1` must outlive `'a`
error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-2995.stderr b/src/test/ui/issues/issue-2995.stderr
index 455d32e233ab9..7616f987d7312 100644
--- a/src/test/ui/issues/issue-2995.stderr
+++ b/src/test/ui/issues/issue-2995.stderr
@@ -6,8 +6,9 @@ LL | let _q: &isize = p as &isize;
|
help: consider borrowing the value
|
-LL | let _q: &isize = &*p as &isize;
- | ++
+LL - let _q: &isize = p as &isize;
+LL + let _q: &isize = &*p;
+ |
error: aborting due to previous error
diff --git a/src/test/ui/lifetimes/lifetime-bound-will-change-warning.nll.stderr b/src/test/ui/lifetimes/lifetime-bound-will-change-warning.nll.stderr
index 050d5fcf05ef4..6f3f84096e400 100644
--- a/src/test/ui/lifetimes/lifetime-bound-will-change-warning.nll.stderr
+++ b/src/test/ui/lifetimes/lifetime-bound-will-change-warning.nll.stderr
@@ -2,19 +2,29 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/lifetime-bound-will-change-warning.rs:34:5
|
LL | fn test2<'a>(x: &'a Box<dyn Fn() + 'a>) {
- | - `x` is a reference that is only valid in the function body
+ | -- - `x` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | // but ref_obj will not, so warn.
LL | ref_obj(x)
- | ^^^^^^^^^^ `x` escapes the function body here
+ | ^^^^^^^^^^
+ | |
+ | `x` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error[E0521]: borrowed data escapes outside of function
--> $DIR/lifetime-bound-will-change-warning.rs:39:5
|
LL | fn test2cc<'a>(x: &'a Box<dyn Fn() + 'a>) {
- | - `x` is a reference that is only valid in the function body
+ | -- - `x` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | // same as test2, but cross crate
LL | lib::ref_obj(x)
- | ^^^^^^^^^^^^^^^ `x` escapes the function body here
+ | ^^^^^^^^^^^^^^^
+ | |
+ | `x` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error: aborting due to 2 previous errors
diff --git a/src/test/ui/mismatched_types/cast-rfc0401.stderr b/src/test/ui/mismatched_types/cast-rfc0401.stderr
index a47eb87cff06c..7f91d5ed42ce4 100644
--- a/src/test/ui/mismatched_types/cast-rfc0401.stderr
+++ b/src/test/ui/mismatched_types/cast-rfc0401.stderr
@@ -28,8 +28,9 @@ LL | let _ = v as &u8;
|
help: consider borrowing the value
|
-LL | let _ = &*v as &u8;
- | ++
+LL - let _ = v as &u8;
+LL + let _ = &*v;
+ |
error[E0605]: non-primitive cast: `*const u8` as `E`
--> $DIR/cast-rfc0401.rs:30:13
diff --git a/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr b/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr
index d17a40a95c1b8..d77793291c5c5 100644
--- a/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr
+++ b/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-no-bound.stderr
@@ -38,14 +38,19 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/propagate-approximated-shorter-to-static-no-bound.rs:32:5
|
LL | fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
- | ------ `cell_a` is a reference that is only valid in the function body
+ | -- ------ `cell_a` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | / establish_relationships(&cell_a, &cell_b, |_outlives, x, y| {
LL | |
LL | |
LL | | // Only works if 'x: 'y:
LL | | demand_y(x, y, x.get())
LL | | });
- | |______^ `cell_a` escapes the function body here
+ | | ^
+ | | |
+ | |______`cell_a` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error: aborting due to previous error
diff --git a/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr b/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr
index 06c46ec8259a0..cc67270ad20c1 100644
--- a/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr
+++ b/src/test/ui/nll/closure-requirements/propagate-approximated-shorter-to-static-wrong-bound.stderr
@@ -38,14 +38,19 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/propagate-approximated-shorter-to-static-wrong-bound.rs:35:5
|
LL | fn supply<'a, 'b>(cell_a: Cell<&'a u32>, cell_b: Cell<&'b u32>) {
- | ------ `cell_a` is a reference that is only valid in the function body
+ | -- ------ `cell_a` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | / establish_relationships(&cell_a, &cell_b, |_outlives1, _outlives2, x, y| {
LL | |
LL | |
LL | | // Only works if 'x: 'y:
LL | | demand_y(x, y, x.get())
LL | | });
- | |______^ `cell_a` escapes the function body here
+ | | ^
+ | | |
+ | |______`cell_a` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error: aborting due to previous error
diff --git a/src/test/ui/nll/issue-67007-escaping-data.rs b/src/test/ui/nll/issue-67007-escaping-data.rs
new file mode 100644
index 0000000000000..8c21737e05fe8
--- /dev/null
+++ b/src/test/ui/nll/issue-67007-escaping-data.rs
@@ -0,0 +1,26 @@
+// Regression test for issue #67007
+// Ensures that we show information about the specific regions involved
+
+#![feature(nll)]
+
+// Covariant over 'a, invariant over 'tcx
+struct FnCtxt<'a, 'tcx: 'a>(&'a (), *mut &'tcx ());
+
+impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
+ fn use_it(&self, _: &'tcx ()) {}
+}
+
+struct Consumer<'tcx>(&'tcx ());
+
+impl<'tcx> Consumer<'tcx> {
+ fn bad_method<'a>(&self, fcx: &FnCtxt<'a, 'tcx>) {
+ let other = self.use_fcx(fcx); //~ ERROR borrowed data
+ fcx.use_it(other);
+ }
+
+ fn use_fcx<'a>(&self, _: &FnCtxt<'a, 'tcx>) -> &'a () {
+ &()
+ }
+}
+
+fn main() {}
diff --git a/src/test/ui/nll/issue-67007-escaping-data.stderr b/src/test/ui/nll/issue-67007-escaping-data.stderr
new file mode 100644
index 0000000000000..2834d6fb0d214
--- /dev/null
+++ b/src/test/ui/nll/issue-67007-escaping-data.stderr
@@ -0,0 +1,21 @@
+error[E0521]: borrowed data escapes outside of associated function
+ --> $DIR/issue-67007-escaping-data.rs:17:21
+ |
+LL | impl<'tcx> Consumer<'tcx> {
+ | ---- lifetime `'tcx` defined here
+LL | fn bad_method<'a>(&self, fcx: &FnCtxt<'a, 'tcx>) {
+ | -- ----- --- `fcx` is a reference that is only valid in the associated function body
+ | | |
+ | | `self` declared here, outside of the associated function body
+ | lifetime `'a` defined here
+LL | let other = self.use_fcx(fcx);
+ | ^^^^^^^^^^^^^^^^^
+ | |
+ | `fcx` escapes the associated function body here
+ | argument requires that `'a` must outlive `'tcx`
+ |
+ = help: consider adding the following bound: `'a: 'tcx`
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0521`.
diff --git a/src/test/ui/nll/outlives-suggestion-simple.stderr b/src/test/ui/nll/outlives-suggestion-simple.stderr
index fa85ce2799083..3b2017d2d03a1 100644
--- a/src/test/ui/nll/outlives-suggestion-simple.stderr
+++ b/src/test/ui/nll/outlives-suggestion-simple.stderr
@@ -92,13 +92,20 @@ LL | self.x
error[E0521]: borrowed data escapes outside of associated function
--> $DIR/outlives-suggestion-simple.rs:73:9
|
+LL | impl<'a> Foo2<'a> {
+ | -- lifetime `'a` defined here
+LL | // should not produce outlives suggestions to name 'self
LL | fn get_bar(&self) -> Bar2 {
| -----
| |
| `self` declared here, outside of the associated function body
| `self` is a reference that is only valid in the associated function body
+ | let's call the lifetime of this reference `'1`
LL | Bar2::new(&self)
- | ^^^^^^^^^^^^^^^^ `self` escapes the associated function body here
+ | ^^^^^^^^^^^^^^^^
+ | |
+ | `self` escapes the associated function body here
+ | argument requires that `'1` must outlive `'a`
error: aborting due to 9 previous errors
diff --git a/src/test/ui/nll/user-annotations/closure-substs.stderr b/src/test/ui/nll/user-annotations/closure-substs.stderr
index 55bb3a6090c01..20002e4591d1a 100644
--- a/src/test/ui/nll/user-annotations/closure-substs.stderr
+++ b/src/test/ui/nll/user-annotations/closure-substs.stderr
@@ -28,9 +28,14 @@ error[E0521]: borrowed data escapes outside of closure
--> $DIR/closure-substs.rs:29:9
|
LL | |x: &i32, b: fn(&'static i32)| {
- | - `x` is a reference that is only valid in the closure body
+ | - - let's call the lifetime of this reference `'1`
+ | |
+ | `x` is a reference that is only valid in the closure body
LL | b(x);
- | ^^^^ `x` escapes the closure body here
+ | ^^^^
+ | |
+ | `x` escapes the closure body here
+ | argument requires that `'1` must outlive `'static`
error: aborting due to 4 previous errors
diff --git a/src/test/ui/object-lifetime/object-lifetime-default-mybox.nll.stderr b/src/test/ui/object-lifetime/object-lifetime-default-mybox.nll.stderr
index 6ce1b2eed85d2..af20c5e5fc0da 100644
--- a/src/test/ui/object-lifetime/object-lifetime-default-mybox.nll.stderr
+++ b/src/test/ui/object-lifetime/object-lifetime-default-mybox.nll.stderr
@@ -15,9 +15,14 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/object-lifetime-default-mybox.rs:31:5
|
LL | fn load2<'a>(ss: &MyBox<dyn SomeTrait + 'a>) -> MyBox<dyn SomeTrait + 'a> {
- | -- `ss` is a reference that is only valid in the function body
+ | -- -- `ss` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | load0(ss)
- | ^^^^^^^^^ `ss` escapes the function body here
+ | ^^^^^^^^^
+ | |
+ | `ss` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error: aborting due to 2 previous errors
diff --git a/src/test/ui/print_type_sizes/uninhabited.rs b/src/test/ui/print_type_sizes/uninhabited.rs
index c234547bd14b1..06a62db4ebb0f 100644
--- a/src/test/ui/print_type_sizes/uninhabited.rs
+++ b/src/test/ui/print_type_sizes/uninhabited.rs
@@ -11,5 +11,5 @@
fn start(_: isize, _: *const *const u8) -> isize {
let _x: Option<!> = None;
let _y: Result<u32, !> = Ok(42);
- 0
+ let _z: Result<!, !> = loop {};
}
diff --git a/src/test/ui/print_type_sizes/uninhabited.stdout b/src/test/ui/print_type_sizes/uninhabited.stdout
index 2a8706f7ac551..5eb5384bce340 100644
--- a/src/test/ui/print_type_sizes/uninhabited.stdout
+++ b/src/test/ui/print_type_sizes/uninhabited.stdout
@@ -3,3 +3,4 @@ print-type-size variant `Ok`: 4 bytes
print-type-size field `.0`: 4 bytes
print-type-size type: `std::option::Option<!>`: 0 bytes, alignment: 1 bytes
print-type-size variant `None`: 0 bytes
+print-type-size type: `std::result::Result<!, !>`: 0 bytes, alignment: 1 bytes
diff --git a/src/test/ui/regions/issue-78262.nll.stderr b/src/test/ui/regions/issue-78262.nll.stderr
index a35d6fd9bf885..721dafac0be76 100644
--- a/src/test/ui/regions/issue-78262.nll.stderr
+++ b/src/test/ui/regions/issue-78262.nll.stderr
@@ -2,8 +2,11 @@ error[E0521]: borrowed data escapes outside of closure
--> $DIR/issue-78262.rs:14:26
|
LL | let f = |x: &dyn TT| x.func();
- | - ^^^^^^^^ `x` escapes the closure body here
- | |
+ | - - ^^^^^^^^
+ | | | |
+ | | | `x` escapes the closure body here
+ | | | argument requires that `'1` must outlive `'static`
+ | | let's call the lifetime of this reference `'1`
| `x` is a reference that is only valid in the closure body
error: aborting due to previous error
diff --git a/src/test/ui/regions/issue-78262.polonius.stderr b/src/test/ui/regions/issue-78262.polonius.stderr
index a35d6fd9bf885..721dafac0be76 100644
--- a/src/test/ui/regions/issue-78262.polonius.stderr
+++ b/src/test/ui/regions/issue-78262.polonius.stderr
@@ -2,8 +2,11 @@ error[E0521]: borrowed data escapes outside of closure
--> $DIR/issue-78262.rs:14:26
|
LL | let f = |x: &dyn TT| x.func();
- | - ^^^^^^^^ `x` escapes the closure body here
- | |
+ | - - ^^^^^^^^
+ | | | |
+ | | | `x` escapes the closure body here
+ | | | argument requires that `'1` must outlive `'static`
+ | | let's call the lifetime of this reference `'1`
| `x` is a reference that is only valid in the closure body
error: aborting due to previous error
diff --git a/src/test/ui/regions/region-invariant-static-error-reporting.nll.stderr b/src/test/ui/regions/region-invariant-static-error-reporting.nll.stderr
index 7221759dbd450..e220cbf555956 100644
--- a/src/test/ui/regions/region-invariant-static-error-reporting.nll.stderr
+++ b/src/test/ui/regions/region-invariant-static-error-reporting.nll.stderr
@@ -2,10 +2,15 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/region-invariant-static-error-reporting.rs:15:9
|
LL | fn unify<'a>(x: Option<Invariant<'a>>, f: fn(Invariant<'a>)) {
- | - `x` is a reference that is only valid in the function body
+ | -- - `x` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | let bad = if x.is_some() {
LL | x.unwrap()
- | ^^^^^^^^^^ `x` escapes the function body here
+ | ^^^^^^^^^^
+ | |
+ | `x` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error: aborting due to previous error
diff --git a/src/test/ui/regions/regions-bounded-method-type-parameters-trait-bound.nll.stderr b/src/test/ui/regions/regions-bounded-method-type-parameters-trait-bound.nll.stderr
index ed7b17c207c30..83d6e13dc0a68 100644
--- a/src/test/ui/regions/regions-bounded-method-type-parameters-trait-bound.nll.stderr
+++ b/src/test/ui/regions/regions-bounded-method-type-parameters-trait-bound.nll.stderr
@@ -2,12 +2,17 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/regions-bounded-method-type-parameters-trait-bound.rs:20:5
|
LL | fn caller2<'a,'b,F:Foo<'a>>(a: Inv<'a>, b: Inv<'b>, f: F) {
- | - - `b` is a reference that is only valid in the function body
- | |
- | `a` declared here, outside of the function body
+ | -- -- - - `b` is a reference that is only valid in the function body
+ | | | |
+ | | | `a` declared here, outside of the function body
+ | | lifetime `'b` defined here
+ | lifetime `'a` defined here
LL | // Here the value provided for 'y is 'b, and hence 'b:'a does not hold.
LL | f.method(b);
- | ^^^^^^^^^^^ `b` escapes the function body here
+ | ^^^^^^^^^^^
+ | |
+ | `b` escapes the function body here
+ | argument requires that `'b` must outlive `'a`
|
= help: consider adding the following bound: `'b: 'a`
diff --git a/src/test/ui/suggestions/impl-on-dyn-trait-with-implicit-static-bound.nll.stderr b/src/test/ui/suggestions/impl-on-dyn-trait-with-implicit-static-bound.nll.stderr
index 32a2de1e84d8f..a1ef32c5445b5 100644
--- a/src/test/ui/suggestions/impl-on-dyn-trait-with-implicit-static-bound.nll.stderr
+++ b/src/test/ui/suggestions/impl-on-dyn-trait-with-implicit-static-bound.nll.stderr
@@ -2,33 +2,53 @@ error[E0521]: borrowed data escapes outside of function
--> $DIR/impl-on-dyn-trait-with-implicit-static-bound.rs:20:9
|
LL | fn use_it<'a, T>(val: &'a dyn ObjectTrait<T>) -> impl OtherTrait<'a> + 'a {
- | --- `val` is a reference that is only valid in the function body
+ | -- --- `val` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | val.use_self::<T>()
- | ^^^^^^^^^^^^^^^^^^^ `val` escapes the function body here
+ | ^^^^^^^^^^^^^^^^^^^
+ | |
+ | `val` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error[E0521]: borrowed data escapes outside of function
--> $DIR/impl-on-dyn-trait-with-implicit-static-bound.rs:69:9
|
LL | fn use_it<'a>(val: &'a dyn ObjectTrait) -> impl OtherTrait<'a> + 'a {
- | --- `val` is a reference that is only valid in the function body
+ | -- --- `val` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | val.use_self()
- | ^^^^^^^^^^^^^^ `val` escapes the function body here
+ | ^^^^^^^^^^^^^^
+ | |
+ | `val` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error[E0521]: borrowed data escapes outside of function
--> $DIR/impl-on-dyn-trait-with-implicit-static-bound.rs:88:9
|
LL | fn use_it<'a>(val: &'a dyn ObjectTrait) -> impl OtherTrait<'a> {
- | --- `val` is a reference that is only valid in the function body
+ | -- --- `val` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | val.use_self()
- | ^^^^^^^^^^^^^^ `val` escapes the function body here
+ | ^^^^^^^^^^^^^^
+ | |
+ | `val` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error[E0521]: borrowed data escapes outside of function
--> $DIR/impl-on-dyn-trait-with-implicit-static-bound.rs:108:9
|
LL | fn use_it<'a>(val: &'a dyn ObjectTrait) -> impl OtherTrait<'a> + 'a {
- | --- `val` is a reference that is only valid in the function body
+ | -- --- `val` is a reference that is only valid in the function body
+ | |
+ | lifetime `'a` defined here
LL | MyTrait::use_self(val)
- | ^^^^^^^^^^^^^^^^^^^^^^ `val` escapes the function body here
+ | ^^^^^^^^^^^^^^^^^^^^^^
+ | |
+ | `val` escapes the function body here
+ | argument requires that `'a` must outlive `'static`
error: aborting due to 4 previous errors