model-checking
diff --git a/‎.github/workflows/flux.yml‎
Lines changed: 1 addition & 1 deletion b/‎.github/workflows/flux.yml‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎library/Cargo.lock‎
Lines changed: 2 additions & 2 deletions b/‎library/Cargo.lock‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎library/alloc/src/boxed/thin.rs‎
Lines changed: 4 additions & 3 deletions b/‎library/alloc/src/boxed/thin.rs‎
Lines changed: 4 additions & 3 deletions
diff --git a/‎library/alloc/src/fmt.rs‎
Lines changed: 2 additions & 2 deletions b/‎library/alloc/src/fmt.rs‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎library/alloc/src/lib.rs‎
Lines changed: 1 addition & 0 deletions b/‎library/alloc/src/lib.rs‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎library/alloc/src/string.rs‎
Lines changed: 1 addition & 1 deletion b/‎library/alloc/src/string.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎library/alloc/src/vec/mod.rs‎
Lines changed: 18 additions & 4 deletions b/‎library/alloc/src/vec/mod.rs‎
Lines changed: 18 additions & 4 deletions
diff --git a/‎library/core/src/any.rs‎
Lines changed: 1 addition & 1 deletion b/‎library/core/src/any.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎library/core/src/array/mod.rs‎
Lines changed: 6 additions & 4 deletions b/‎library/core/src/array/mod.rs‎
Lines changed: 6 additions & 4 deletions
diff --git a/‎library/core/src/async_iter/async_iter.rs‎
Lines changed: 5 additions & 5 deletions b/‎library/core/src/async_iter/async_iter.rs‎
Lines changed: 5 additions & 5 deletions
@@ -9,7 +9,7 @@ on:
 
 env:
   FIXPOINT_VERSION: "556104ba5508891c357b0bdf819ce706e93d9349"
-  FLUX_VERSION: "f6bdf90c54ad6eed51b25c125f251cac01cfe170"
+  FLUX_VERSION: "ebafb8d0ca32d8c0fcd2a0cfef6b1b4bd4dc4a6f"
 
 jobs:
   check-flux-on-core:
 
@@ -5,7 +5,7 @@
 use core::error::Error;
 use core::fmt::{self, Debug, Display, Formatter};
 #[cfg(not(no_global_oom_handling))]
-use core::intrinsics::const_allocate;
+use core::intrinsics::{const_allocate, const_make_global};
 use core::marker::PhantomData;
 #[cfg(not(no_global_oom_handling))]
 use core::marker::Unsize;
@@ -340,9 +340,10 @@ impl<H> WithHeader<H> {
                     alloc.add(metadata_offset).cast();
                 // SAFETY: `*metadata_ptr` is within the allocation.
                 metadata_ptr.write(ptr::metadata::<Dyn>(ptr::dangling::<T>() as *const Dyn));
-
+                // SAFETY: valid heap allocation
+                const_make_global(alloc);
                 // SAFETY: we have just written the metadata.
-                &*(metadata_ptr)
+                &*metadata_ptr
             }
         };
 
 
@@ -348,13 +348,13 @@
 //! format := '{' [ argument ] [ ':' format_spec ] [ ws ] * '}'
 //! argument := integer | identifier
 //!
-//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision]type
+//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision][type]
 //! fill := character
 //! align := '<' | '^' | '>'
 //! sign := '+' | '-'
 //! width := count
 //! precision := count | '*'
-//! type := '' | '?' | 'x?' | 'X?' | identifier
+//! type := '?' | 'x?' | 'X?' | identifier
 //! count := parameter | integer
 //! parameter := argument '$'
 //! ```
 
@@ -156,6 +156,7 @@
 #![feature(try_trait_v2)]
 #![feature(try_with_capacity)]
 #![feature(tuple_trait)]
+#![feature(ub_checks)]
 #![feature(unicode_internals)]
 #![feature(unsize)]
 #![feature(unwrap_infallible)]
 
@@ -2611,7 +2611,7 @@ impl_eq! { Cow<'a, str>, &'b str }
 impl_eq! { Cow<'a, str>, String }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl const Default for String {
     /// Creates an empty `String`.
     #[inline]
 
@@ -64,7 +64,7 @@ use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
 use core::ops::{self, Index, IndexMut, Range, RangeBounds};
 use core::ptr::{self, NonNull};
 use core::slice::{self, SliceIndex};
-use core::{fmt, intrinsics};
+use core::{fmt, intrinsics, ub_checks};
 
 #[stable(feature = "extract_if", since = "1.87.0")]
 pub use self::extract_if::ExtractIf;
@@ -1058,6 +1058,11 @@ impl<T, A: Allocator> Vec<T, A> {
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
     pub unsafe fn from_raw_parts_in(ptr: *mut T, length: usize, capacity: usize, alloc: A) -> Self {
+        ub_checks::assert_unsafe_precondition!(
+            check_library_ub,
+            "Vec::from_raw_parts_in requires that length <= capacity",
+            (length: usize = length, capacity: usize = capacity) => length <= capacity
+        );
         unsafe { Vec { buf: RawVec::from_raw_parts_in(ptr, capacity, alloc), len: length } }
     }
 
@@ -1174,6 +1179,11 @@ impl<T, A: Allocator> Vec<T, A> {
     #[unstable(feature = "allocator_api", reason = "new API", issue = "32838")]
     // #[unstable(feature = "box_vec_non_null", issue = "130364")]
     pub unsafe fn from_parts_in(ptr: NonNull<T>, length: usize, capacity: usize, alloc: A) -> Self {
+        ub_checks::assert_unsafe_precondition!(
+            check_library_ub,
+            "Vec::from_parts_in requires that length <= capacity",
+            (length: usize = length, capacity: usize = capacity) => length <= capacity
+        );
         unsafe { Vec { buf: RawVec::from_nonnull_in(ptr, capacity, alloc), len: length } }
     }
 
@@ -1950,7 +1960,11 @@ impl<T, A: Allocator> Vec<T, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub unsafe fn set_len(&mut self, new_len: usize) {
-        debug_assert!(new_len <= self.capacity());
+        ub_checks::assert_unsafe_precondition!(
+            check_library_ub,
+            "Vec::set_len requires that new_len <= capacity()",
+            (new_len: usize = new_len, capacity: usize = self.capacity()) => new_len <= capacity
+        );
 
         self.len = new_len;
     }
@@ -3695,7 +3709,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// This is optimal if:
     ///
     /// * The tail (elements in the vector after `range`) is empty,
-    /// * or `replace_with` yields fewer or equal elements than `range`’s length
+    /// * or `replace_with` yields fewer or equal elements than `range`'s length
     /// * or the lower bound of its `size_hint()` is exact.
     ///
     /// Otherwise, a temporary vector is allocated and the tail is moved twice.
@@ -3895,7 +3909,7 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_unstable(feature = "const_default", issue = "67792")]
+#[rustc_const_unstable(feature = "const_default", issue = "143894")]
 impl<T> const Default for Vec<T> {
     /// Creates an empty `Vec<T>`.
     ///
 
@@ -783,7 +783,7 @@ impl TypeId {
 
         // This is a provenance-stripping memcpy.
         for (i, chunk) in self.data.iter().copied().enumerate() {
-            let chunk = chunk.expose_provenance().to_ne_bytes();
+            let chunk = chunk.addr().to_ne_bytes();
             let start = i * chunk.len();
             bytes[start..(start + chunk.len())].copy_from_slice(&chunk);
         }
 
@@ -374,9 +374,10 @@ impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N] {
 }
 
 #[stable(feature = "index_trait_on_arrays", since = "1.50.0")]
-impl<T, I, const N: usize> Index<I> for [T; N]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T, I, const N: usize> const Index<I> for [T; N]
 where
-    [T]: Index<I>,
+    [T]: ~const Index<I>,
 {
     type Output = <[T] as Index<I>>::Output;
 
@@ -387,9 +388,10 @@ where
 }
 
 #[stable(feature = "index_trait_on_arrays", since = "1.50.0")]
-impl<T, I, const N: usize> IndexMut<I> for [T; N]
+#[rustc_const_unstable(feature = "const_index", issue = "143775")]
+impl<T, I, const N: usize> const IndexMut<I> for [T; N]
 where
-    [T]: IndexMut<I>,
+    [T]: ~const IndexMut<I>,
 {
     #[inline]
     fn index_mut(&mut self, index: I) -> &mut Self::Output {
 
@@ -28,15 +28,15 @@ pub trait AsyncIterator {
     /// async iterator state:
     ///
     /// - `Poll::Pending` means that this async iterator's next value is not ready
-    /// yet. Implementations will ensure that the current task will be notified
-    /// when the next value may be ready.
+    ///   yet. Implementations will ensure that the current task will be notified
+    ///   when the next value may be ready.
     ///
     /// - `Poll::Ready(Some(val))` means that the async iterator has successfully
-    /// produced a value, `val`, and may produce further values on subsequent
-    /// `poll_next` calls.
+    ///   produced a value, `val`, and may produce further values on subsequent
+    ///   `poll_next` calls.
     ///
     /// - `Poll::Ready(None)` means that the async iterator has terminated, and
-    /// `poll_next` should not be invoked again.
+    ///   `poll_next` should not be invoked again.
     ///
     /// # Panics
     ///
Original file line number	Diff line number	Diff line change
`@@ -783,7 +783,7 @@ impl TypeId {`
`783`	`783`
`784`	`784`	`// This is a provenance-stripping memcpy.`
`785`	`785`	`for (i, chunk) in self.data.iter().copied().enumerate() {`
`786`		`- let chunk = chunk.expose_provenance().to_ne_bytes();`
	`786`	`+ let chunk = chunk.addr().to_ne_bytes();`
`787`	`787`	`let start = i * chunk.len();`
`788`	`788`	`bytes[start..(start + chunk.len())].copy_from_slice(&chunk);`
`789`	`789`	`}`
Original file line number	Diff line number	Diff line change
`@@ -374,9 +374,10 @@ impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N] {`
`374`	`374`	`}`
`375`	`375`
`376`	`376`	`#[stable(feature = "index_trait_on_arrays", since = "1.50.0")]`
`377`		`-impl<T, I, const N: usize> Index<I> for [T; N]`
	`377`	`+#[rustc_const_unstable(feature = "const_index", issue = "143775")]`
	`378`	`+impl<T, I, const N: usize> const Index<I> for [T; N]`
`378`	`379`	`where`
`379`		`- [T]: Index<I>,`
	`380`	`+ [T]: ~const Index<I>,`
`380`	`381`	`{`
`381`	`382`	`type Output = <[T] as Index<I>>::Output;`
`382`	`383`
`@@ -387,9 +388,10 @@ where`
`387`	`388`	`}`
`388`	`389`
`389`	`390`	`#[stable(feature = "index_trait_on_arrays", since = "1.50.0")]`
`390`		`-impl<T, I, const N: usize> IndexMut<I> for [T; N]`
	`391`	`+#[rustc_const_unstable(feature = "const_index", issue = "143775")]`
	`392`	`+impl<T, I, const N: usize> const IndexMut<I> for [T; N]`
`391`	`393`	`where`
`392`		`- [T]: IndexMut<I>,`
	`394`	`+ [T]: ~const IndexMut<I>,`
`393`	`395`	`{`
`394`	`396`	`#[inline]`
`395`	`397`	`fn index_mut(&mut self, index: I) -> &mut Self::Output {`