Auto merge of rust-lang#87156 - JohnTitor:rollup-osuhe53, r=JohnTitor

Rollup of 8 pull requests

Successful merges:

 - rust-lang#85579 (Added Arc::try_pin)
 - rust-lang#86478 (Add -Zfuture-incompat-test to assist with testing future-incompat reports.)
 - rust-lang#86947 (Move assert_matches to an inner module)
 - rust-lang#87081 (Add tracking issue number to `wasi_ext`)
 - rust-lang#87127 (Add safety comments in private core::slice::rotate::ptr_rotate function)
 - rust-lang#87134 (Make SelfInTyParamDefault wording not be specific to type defaults)
 - rust-lang#87147 (Update cargo)
 - rust-lang#87154 (Fix misuse of rev attribute on <a> tag)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_interface/src/tests.rs

@@ -633,6 +633,7 @@ fn test_debugging_options_tracking_hash() {
  untracked!(dump_mir_graphviz, true);
  untracked!(emit_future_incompat_report, true);
  untracked!(emit_stack_sizes, true);
+ untracked!(future_incompat_test, true);
  untracked!(hir_stats, true);
  untracked!(identify_regions, true);
  untracked!(incremental_ignore_spans, true);

compiler/rustc_middle/src/ich/impls_syntax.rs

@@ -6,6 +6,7 @@ use crate::ich::StableHashingContext;
 use rustc_ast as ast;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_span::{BytePos, NormalizedPos, SourceFile};
+use std::assert::assert_matches;
 
 use smallvec::SmallVec;
 

compiler/rustc_middle/src/lint.rs

@@ -8,7 +8,7 @@ use rustc_hir::HirId;
 use rustc_index::vec::IndexVec;
 use rustc_session::lint::{
  builtin::{self, FORBIDDEN_LINT_GROUPS},
- FutureIncompatibilityReason, FutureIncompatibleInfo, Level, Lint, LintId,
+ FutureIncompatibilityReason, Level, Lint, LintId,
 };
 use rustc_session::{DiagnosticMessageId, Session};
 use rustc_span::hygiene::MacroKind;
@@ -223,12 +223,12 @@ pub fn struct_lint_level<'s, 'd>(
  let lint_id = LintId::of(lint);
  let future_incompatible = lint.future_incompatible;
 
- let has_future_breakage = matches!(
- future_incompatible,
- Some(FutureIncompatibleInfo {
-  reason: FutureIncompatibilityReason::FutureReleaseErrorReportNow,
- ..
- })
+ let has_future_breakage = future_incompatible.map_or(
+ // Default allow lints trigger too often for testing.
+ sess.opts.debugging_opts.future_incompat_test && lint.default_level != Level::Allow,
+ |incompat| {
+ matches!(incompat.reason, FutureIncompatibilityReason::FutureReleaseErrorReportNow)
+ },
  );
 
  let mut err = match (level, span) {

compiler/rustc_mir/src/interpret/memory.rs

@@ -6,6 +6,7 @@
 //! integer. It is crucial that these operations call `check_align` *before*
 //! short-circuiting the empty case!
 
+use std::assert::assert_matches;
 use std::borrow::Cow;
 use std::collections::VecDeque;
 use std::convert::{TryFrom, TryInto};

compiler/rustc_resolve/src/diagnostics.rs

@@ -502,14 +502,14 @@ impl<'a> Resolver<'a> {
 
  err
  }
- ResolutionError::SelfInTyParamDefault => {
+ ResolutionError::SelfInGenericParamDefault => {
  let mut err = struct_span_err!(
  self.session,
  span,
  E0735,
- "type parameters cannot use `Self` in their defaults"
+ "generic parameters cannot use `Self` in their defaults"
  );
- err.span_label(span, "`Self` in type parameter default".to_string());
+ err.span_label(span, "`Self` in generic parameter default".to_string());
  err
  }
  ResolutionError::UnreachableLabel { name, definition_span, suggestion } => {

compiler/rustc_resolve/src/lib.rs

@@ -249,7 +249,7 @@ enum ResolutionError<'a> {
  /// This error is only emitted when using `min_const_generics`.
  ParamInNonTrivialAnonConst { name: Symbol, is_type: bool },
  /// Error E0735: generic parameters with a default cannot use `Self`
- SelfInTyParamDefault,
+ SelfInGenericParamDefault,
  /// Error E0767: use of unreachable label
  UnreachableLabel { name: Symbol, definition_span: Span, suggestion: Option<LabelSuggestion> },
 }
@@ -2643,7 +2643,7 @@ impl<'a> Resolver<'a> {
  if let ForwardGenericParamBanRibKind = all_ribs[rib_index].kind {
  if record_used {
  let res_error = if rib_ident.name == kw::SelfUpper {
- ResolutionError::SelfInTyParamDefault
+ ResolutionError::SelfInGenericParamDefault
  } else {
  ResolutionError::ForwardDeclaredGenericParam
  };

compiler/rustc_session/src/options.rs

@@ -1084,6 +1084,8 @@ options! {
  "set the optimization fuel quota for a crate"),
  function_sections: Option<bool> = (None, parse_opt_bool, [TRACKED],
  "whether each function should go in its own section"),
+ future_incompat_test: bool = (false, parse_bool, [UNTRACKED],
+ "forces all lints to be future incompatible, used for internal testing (default: no)"),
  gcc_ld: Option<LdImpl> = (None, parse_gcc_ld, [TRACKED], "implementation of ld used by cc"),
  graphviz_dark_mode: bool = (false, parse_bool, [UNTRACKED],
  "use dark-themed colors in graphviz output (default: no)"),

library/alloc/src/sync.rs

@@ -19,7 +19,6 @@ use core::marker::{PhantomData, Unpin, Unsize};
 use core::mem::size_of_val;
 use core::mem::{self, align_of_val_raw};
 use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
-#[cfg(not(no_global_oom_handling))]
 use core::pin::Pin;
 use core::ptr::{self, NonNull};
 #[cfg(not(no_global_oom_handling))]
@@ -494,6 +493,13 @@ impl<T> Arc<T> {
  unsafe { Pin::new_unchecked(Arc::new(data)) }
  }
 
+ /// Constructs a new `Pin<Arc<T>>`, return an error if allocation fails.
+ #[unstable(feature = "allocator_api", issue = "32838")]
+ #[inline]
+ pub fn try_pin(data: T) -> Result<Pin<Arc<T>>, AllocError> {
+ unsafe { Ok(Pin::new_unchecked(Arc::try_new(data)?)) }
+ }
+
  /// Constructs a new `Arc<T>`, returning an error if allocation fails.
  ///
  /// # Examples

library/core/src/lib.rs

@@ -179,6 +179,16 @@ use prelude::v1::*;
 #[macro_use]
 mod macros;
 
+// We don't export this through #[macro_export] for now, to avoid breakage.
+// See https://github.com/rust-lang/rust/issues/82913
+#[cfg(not(test))]
+#[unstable(feature = "assert_matches", issue = "82775")]
+/// Unstable module containing the unstable `assert_matches` macro.
+pub mod assert {
+ #[unstable(feature = "assert_matches", issue = "82775")]
+ pub use crate::macros::{assert_matches, debug_assert_matches};
+}
+
 #[macro_use]
 mod internal_macros;
 

library/core/src/macros/mod.rs

@@ -127,6 +127,8 @@ macro_rules! assert_ne {
 /// ```
 /// #![feature(assert_matches)]
 ///
+/// use std::assert::assert_matches;
+///
 /// let a = 1u32.checked_add(2);
 /// let b = 1u32.checked_sub(2);
 /// assert_matches!(a, Some(_));
@@ -135,10 +137,10 @@ macro_rules! assert_ne {
 /// let c = Ok("abc".to_string());
 /// assert_matches!(c, Ok(x) | Err(x) if x.len() < 100);
 /// ```
-#[macro_export]
 #[unstable(feature = "assert_matches", issue = "82775")]
 #[allow_internal_unstable(core_panic)]
-macro_rules! assert_matches {
+#[rustc_macro_transparency = "semitransparent"]
+pub macro assert_matches {
  ($left:expr, $( $pattern:pat_param )|+ $( if $guard: expr )? $(,)?) => ({
  match $left {
  $( $pattern )|+ $( if $guard )? => {}
@@ -150,7 +152,7 @@ macro_rules! assert_matches {
  );
  }
  }
- });
+ }),
  ($left:expr, $( $pattern:pat_param )|+ $( if $guard: expr )?, $($arg:tt)+) => ({
  match $left {
  $( $pattern )|+ $( if $guard )? => {}
@@ -162,7 +164,7 @@ macro_rules! assert_matches {
  );
  }
  }
- });
+ }),
 }
 
 /// Asserts that a boolean expression is `true` at runtime.
@@ -284,6 +286,8 @@ macro_rules! debug_assert_ne {
 /// ```
 /// #![feature(assert_matches)]
 ///
+/// use std::assert::debug_assert_matches;
+///
 /// let a = 1u32.checked_add(2);
 /// let b = 1u32.checked_sub(2);
 /// debug_assert_matches!(a, Some(_));
@@ -295,8 +299,9 @@ macro_rules! debug_assert_ne {
 #[macro_export]
 #[unstable(feature = "assert_matches", issue = "82775")]
 #[allow_internal_unstable(assert_matches)]
-macro_rules! debug_assert_matches {
- ($($arg:tt)*) => (if $crate::cfg!(debug_assertions) { $crate::assert_matches!($($arg)*); })
+#[rustc_macro_transparency = "semitransparent"]
+pub macro debug_assert_matches($($arg:tt)*) {
+ if $crate::cfg!(debug_assertions) { $crate::assert::assert_matches!($($arg)*); }
 }
 
 /// Returns whether the given expression matches any of the given patterns.

library/core/src/slice/rotate.rs

@@ -1,5 +1,3 @@
-// ignore-tidy-undocumented-unsafe
-
 use crate::cmp;
 use crate::mem::{self, MaybeUninit};
 use crate::ptr;
@@ -79,8 +77,10 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  // the way until about `left + right == 32`, but the worst case performance breaks even
  // around 16. 24 was chosen as middle ground. If the size of `T` is larger than 4
  // `usize`s, this algorithm also outperforms other algorithms.
+ // SAFETY: callers must ensure `mid - left` is valid for reading and writing.
  let x = unsafe { mid.sub(left) };
  // beginning of first round
+ // SAFETY: see previous comment.
  let mut tmp: T = unsafe { x.read() };
  let mut i = right;
  // `gcd` can be found before hand by calculating `gcd(left + right, right)`,
@@ -92,6 +92,21 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  // the very end. This is possibly due to the fact that swapping or replacing temporaries
  // uses only one memory address in the loop instead of needing to manage two.
  loop {
+ // [long-safety-expl]
+ // SAFETY: callers must ensure `[left, left+mid+right)` are all valid for reading and
+ // writing.
+ //
+ // - `i` start with `right` so `mid-left <= x+i = x+right = mid-left+right < mid+right`
+ // - `i <= left+right-1` is always true
+ // - if `i < left`, `right` is added so `i < left+right` and on the next
+ // iteration `left` is removed from `i` so it doesn't go further
+ // - if `i >= left`, `left` is removed immediately and so it doesn't go further.
+ // - overflows cannot happen for `i` since the function's safety contract ask for
+ // `mid+right-1 = x+left+right` to be valid for writing
+ // - underflows cannot happen because `i` must be bigger or equal to `left` for
+ // a substraction of `left` to happen.
+ //
+ // So `x+i` is valid for reading and writing if the caller respected the contract
  tmp = unsafe { x.add(i).replace(tmp) };
  // instead of incrementing `i` and then checking if it is outside the bounds, we
  // check if `i` will go outside the bounds on the next increment. This prevents
@@ -100,6 +115,8 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  i -= left;
  if i == 0 {
  // end of first round
+ // SAFETY: tmp has been read from a valid source and x is valid for writing
+ // according to the caller.
  unsafe { x.write(tmp) };
  break;
  }
@@ -113,13 +130,24 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  }
  // finish the chunk with more rounds
  for start in 1..gcd {
+ // SAFETY: `gcd` is at most equal to `right` so all values in `1..gcd` are valid for
+ // reading and writing as per the function's safety contract, see [long-safety-expl]
+ // above
  tmp = unsafe { x.add(start).read() };
+ // [safety-expl-addition]
+ //
+ // Here `start < gcd` so `start < right` so `i < right+right`: `right` being the
+ // greatest common divisor of `(left+right, right)` means that `left = right` so
+ // `i < left+right` so `x+i = mid-left+i` is always valid for reading and writing
+ // according to the function's safety contract.
  i = start + right;
  loop {
+ // SAFETY: see [long-safety-expl] and [safety-expl-addition]
  tmp = unsafe { x.add(i).replace(tmp) };
  if i >= left {
  i -= left;
  if i == start {
+ // SAFETY: see [long-safety-expl] and [safety-expl-addition]
  unsafe { x.add(start).write(tmp) };
  break;
  }
@@ -135,14 +163,30 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  // The `[T; 0]` here is to ensure this is appropriately aligned for T
  let mut rawarray = MaybeUninit::<(BufType, [T; 0])>::uninit();
  let buf = rawarray.as_mut_ptr() as *mut T;
+ // SAFETY: `mid-left <= mid-left+right < mid+right`
  let dim = unsafe { mid.sub(left).add(right) };
  if left <= right {
+ // SAFETY:
+ //
+ // 1) The `else if` condition about the sizes ensures `[mid-left; left]` will fit in
+ // `buf` without overflow and `buf` was created just above and so cannot be
+ // overlapped with any value of `[mid-left; left]`
+ // 2) [mid-left, mid+right) are all valid for reading and writing and we don't care
+ // about overlaps here.
+ // 3) The `if` condition about `left <= right` ensures writing `left` elements to
+ // `dim = mid-left+right` is valid because:
+ // - `buf` is valid and `left` elements were written in it in 1)
+ // - `dim+left = mid-left+right+left = mid+right` and we write `[dim, dim+left)`
  unsafe {
+ // 1)
  ptr::copy_nonoverlapping(mid.sub(left), buf, left);
+ // 2)
  ptr::copy(mid, mid.sub(left), right);
+ // 3)
  ptr::copy_nonoverlapping(buf, dim, left);
  }
  } else {
+ // SAFETY: same reasoning as above but with `left` and `right` reversed
  unsafe {
  ptr::copy_nonoverlapping(mid, buf, right);
  ptr::copy(mid.sub(left), dim, left);
@@ -156,6 +200,10 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  // of this algorithm would be, and swapping using that last chunk instead of swapping
  // adjacent chunks like this algorithm is doing, but this way is still faster.
  loop {
+ // SAFETY:
+ // `left >= right` so `[mid-right, mid+right)` is valid for reading and writing
+ // Substracting `right` from `mid` each turn is counterbalanced by the addition and
+ // check after it.
  unsafe {
  ptr::swap_nonoverlapping(mid.sub(right), mid, right);
  mid = mid.sub(right);
@@ -168,6 +216,10 @@ pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize)
  } else {
  // Algorithm 3, `left < right`
  loop {
+ // SAFETY: `[mid-left, mid+left)` is valid for reading and writing because
+ // `left < right` so `mid+left < mid+right`.
+ // Adding `left` to `mid` each turn is counterbalanced by the substraction and check
+ // after it.
  unsafe {
  ptr::swap_nonoverlapping(mid.sub(left), mid, left);
  mid = mid.add(left);

library/std/src/lib.rs

@@ -548,8 +548,8 @@ pub use std_detect::{
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(deprecated, deprecated_in_future)]
 pub use core::{
- assert_eq, assert_matches, assert_ne, debug_assert, debug_assert_eq, debug_assert_matches,
- debug_assert_ne, matches, r#try, todo, unimplemented, unreachable, write, writeln,
+ assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, matches, r#try, todo,
+ unimplemented, unreachable, write, writeln,
 };
 
 // Re-export built-in macros defined through libcore.

library/std/src/os/wasi/fs.rs

@@ -1,7 +1,7 @@
 //! WASI-specific extensions to primitives in the `std::fs` module.
 
 #![deny(unsafe_op_in_unsafe_fn)]
-#![unstable(feature = "wasi_ext", issue = "none")]
+#![unstable(feature = "wasi_ext", issue = "71213")]
 
 use crate::ffi::OsStr;
 use crate::fs::{self, File, Metadata, OpenOptions};

library/std/src/os/wasi/io.rs

@@ -1,7 +1,7 @@
 //! WASI-specific extensions to general I/O primitives
 
 #![deny(unsafe_op_in_unsafe_fn)]
-#![unstable(feature = "wasi_ext", issue = "none")]
+#![unstable(feature = "wasi_ext", issue = "71213")]
 
 use crate::fs;
 use crate::io;

src/librustdoc/html/markdown.rs

@@ -621,8 +621,7 @@ impl<'a, I: Iterator<Item = SpannedEvent<'a>>> Iterator for Footnotes<'a, I> {
  is_paragraph = true;
  }
  html::push_html(&mut ret, content.into_iter());
- write!(ret, "&nbsp;<a href=\"#fnref{}\" rev=\"footnote\">↩</a>", id)
- .unwrap();
+ write!(ret, "&nbsp;<a href=\"#fnref{}\">↩</a>", id).unwrap();
  if is_paragraph {
  ret.push_str("</p>");
  }

src/test/ui/const-generics/defaults/default-const-param-cannot-reference-self.rs

@@ -0,0 +1,16 @@
+#![feature(const_generics_defaults)]
+
+struct Struct<const N: usize = { Self; 10 }>;
+//~^ ERROR generic parameters cannot use `Self` in their defaults [E0735]
+
+enum Enum<const N: usize = { Self; 10 }> { }
+//~^ ERROR generic parameters cannot use `Self` in their defaults [E0735]
+
+union Union<const N: usize = { Self; 10 }> { not_empty: () }
+//~^ ERROR generic parameters cannot use `Self` in their defaults [E0735]
+
+fn main() {
+ let _: Struct;
+ let _: Enum;
+ let _: Union;
+}