Rollup of 12 pull requests

src/doc/unstable-book/src/language-features/rustc-attrs.md

@@ -0,0 +1,53 @@
+# `rustc_attrs`
+
+This feature has no tracking issue, and is therefore internal to
+the compiler, not being intended for general use.
+
+Note: `rustc_attrs` enables many rustc-internal attributes and this page
+only discuss a few of them.
+
+------------------------
+
+The `rustc_attrs` feature allows debugging rustc type layouts by using
+`#[rustc_layout(...)]` to debug layout at compile time (it even works
+with `cargo check`) as an alternative to `rustc -Z print-type-sizes`
+that is way more verbose.
+
+Options provided by `#[rustc_layout(...)]` are `debug`, `size`, `abi`.
+Note that it only work best with sized type without generics.
+
+## Examples
+
+```rust,ignore
+#![feature(rustc_attrs)]
+
+#[rustc_layout(abi, size)]
+pub enum X {
+ Y(u8, u8, u8),
+ Z(isize),
+}
+```
+
+When that is compiled, the compiler will error with something like
+
+```text
+error: abi: Aggregate { sized: true }
+ --> src/lib.rs:4:1
+ |
+4 | / pub enum T {
+5 | | Y(u8, u8, u8),
+6 | | Z(isize),
+7 | | }
+ | |_^
+
+error: size: Size { raw: 16 }
+ --> src/lib.rs:4:1
+ |
+4 | / pub enum T {
+5 | | Y(u8, u8, u8),
+6 | | Z(isize),
+7 | | }
+ | |_^
+
+error: aborting due to 2 previous errors
+```

src/liballoc/string.rs

@@ -1774,6 +1774,15 @@ impl FromIterator<String> for String {
  }
 }
 
+#[stable(feature = "box_str2", since = "1.45.0")]
+impl FromIterator<Box<str>> for String {
+ fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String {
+ let mut buf = String::new();
+ buf.extend(iter);
+ buf
+ }
+}
+
 #[stable(feature = "herd_cows", since = "1.19.0")]
 impl<'a> FromIterator<Cow<'a, str>> for String {
  fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String {
@@ -1842,6 +1851,13 @@ impl<'a> Extend<&'a str> for String {
  }
 }
 
+#[stable(feature = "box_str2", since = "1.45.0")]
+impl Extend<Box<str>> for String {
+ fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I) {
+ iter.into_iter().for_each(move |s| self.push_str(&s));
+ }
+}
+
 #[stable(feature = "extend_string", since = "1.4.0")]
 impl Extend<String> for String {
  fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {

src/liballoc/sync.rs

@@ -419,8 +419,7 @@ impl<T> Arc<T> {
  #[inline]
  #[stable(feature = "arc_unique", since = "1.4.0")]
  pub fn try_unwrap(this: Self) -> Result<T, Self> {
- // See `drop` for why all these atomics are like this
- if this.inner().strong.compare_exchange(1, 0, Release, Relaxed).is_err() {
+ if this.inner().strong.compare_exchange(1, 0, Relaxed, Relaxed).is_err() {
  return Err(this);
  }
 

src/libcore/intrinsics.rs

@@ -2004,12 +2004,6 @@ extern "rust-intrinsic" {
  pub fn ptr_guaranteed_ne<T>(ptr: *const T, other: *const T) -> bool;
 }
 
-#[rustc_const_unstable(feature = "variant_count", issue = "73662")]
-#[cfg(bootstrap)]
-pub const fn variant_count<T>() -> usize {
- 0
-}
-
 // Some functions are defined here because they accidentally got made
 // available in this module on stable. See <https://github.com/rust-lang/rust/issues/15702>.
 // (`transmute` also falls into this category, but it cannot be wrapped due to the

src/libcore/iter/traits/iterator.rs

@@ -1521,7 +1521,7 @@ pub trait Iterator {
  ///
  /// let iter = a.iter();
  ///
- /// let sum: i32 = iter.take(5).fold(0, |acc, i| acc + i );
+ /// let sum: i32 = iter.take(5).fold(0, |acc, i| acc + i);
  ///
  /// assert_eq!(sum, 6);
  ///
@@ -1535,7 +1535,7 @@ pub trait Iterator {
  /// let mut iter = a.iter();
  ///
  /// // instead, we add in a .by_ref()
- /// let sum: i32 = iter.by_ref().take(2).fold(0, |acc, i| acc + i );
+ /// let sum: i32 = iter.by_ref().take(2).fold(0, |acc, i| acc + i);
  ///
  /// assert_eq!(sum, 3);
  ///

src/libcore/lib.rs

@@ -125,7 +125,7 @@
 #![feature(unsized_locals)]
 #![feature(untagged_unions)]
 #![feature(unwind_attributes)]
-#![feature(variant_count)]
+#![cfg_attr(not(bootstrap), feature(variant_count))]
 #![feature(doc_alias)]
 #![feature(mmx_target_feature)]
 #![feature(tbm_target_feature)]

src/libcore/mem/mod.rs

@@ -1037,6 +1037,7 @@ pub const fn discriminant<T>(v: &T) -> Discriminant<T> {
 /// assert_eq!(mem::variant_count::<Result<!, !>>(), 2);
 /// ```
 #[inline(always)]
+#[cfg(not(bootstrap))]
 #[unstable(feature = "variant_count", issue = "73662")]
 #[rustc_const_unstable(feature = "variant_count", issue = "73662")]
 pub const fn variant_count<T>() -> usize {

src/librustc_feature/active.rs

@@ -570,6 +570,9 @@ declare_features! (
  /// Allows capturing variables in scope using format_args!
  (active, format_args_capture, "1.46.0", Some(67984), None),
 
+ /// Lazily evaluate constants. This allows constants to depend on type parameters.
+ (active, lazy_normalization_consts, "1.46.0", Some(72219), None),
+
  // -------------------------------------------------------------------------
  // feature-group-end: actual feature gates
  // -------------------------------------------------------------------------
@@ -586,5 +589,6 @@ pub const INCOMPLETE_FEATURES: &[Symbol] = &[
  sym::raw_dylib,
  sym::const_trait_impl,
  sym::const_trait_bound_opt_out,
+ sym::lazy_normalization_consts,
  sym::specialization,
 ];

src/librustc_infer/infer/combine.rs

@@ -112,7 +112,7 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
 
  // All other cases of inference are errors
  (&ty::Infer(_), _) | (_, &ty::Infer(_)) => {
- Err(TypeError::Sorts(ty::relate::expected_found(relation, &a, &b)))
+ Err(TypeError::Sorts(ty::relate::expected_found(relation, a, b)))
  }
 
  _ => ty::relate::super_relate_tys(relation, a, b),
@@ -701,21 +701,21 @@ pub fn const_unification_error<'tcx>(
  a_is_expected: bool,
  (a, b): (&'tcx ty::Const<'tcx>, &'tcx ty::Const<'tcx>),
 ) -> TypeError<'tcx> {
- TypeError::ConstMismatch(ty::relate::expected_found_bool(a_is_expected, &a, &b))
+ TypeError::ConstMismatch(ty::relate::expected_found_bool(a_is_expected, a, b))
 }
 
 fn int_unification_error<'tcx>(
  a_is_expected: bool,
  v: (ty::IntVarValue, ty::IntVarValue),
 ) -> TypeError<'tcx> {
  let (a, b) = v;
- TypeError::IntMismatch(ty::relate::expected_found_bool(a_is_expected, &a, &b))
+ TypeError::IntMismatch(ty::relate::expected_found_bool(a_is_expected, a, b))
 }
 
 fn float_unification_error<'tcx>(
  a_is_expected: bool,
  v: (ty::FloatVarValue, ty::FloatVarValue),
 ) -> TypeError<'tcx> {
  let (ty::FloatVarValue(a), ty::FloatVarValue(b)) = v;
- TypeError::FloatMismatch(ty::relate::expected_found_bool(a_is_expected, &a, &b))
+ TypeError::FloatMismatch(ty::relate::expected_found_bool(a_is_expected, a, b))
 }

src/librustc_middle/ty/context.rs

@@ -1370,7 +1370,7 @@ impl<'tcx> TyCtxt<'tcx> {
  /// we still evaluate them eagerly.
  #[inline]
  pub fn lazy_normalization(self) -> bool {
- self.features().const_generics
+ self.features().const_generics || self.features().lazy_normalization_consts
  }
 
  #[inline]

src/librustc_middle/ty/print/pretty.rs

@@ -282,26 +282,27 @@ pub trait PrettyPrinter<'tcx>:
  // where there is no explicit `extern crate`, we just prepend
  // the crate name.
  match self.tcx().extern_crate(def_id) {
- Some(&ExternCrate {
- src: ExternCrateSource::Extern(def_id),
- dependency_of: LOCAL_CRATE,
- span,
- ..
- }) => {
- debug!("try_print_visible_def_path: def_id={:?}", def_id);
- return Ok((
- if !span.is_dummy() {
- self.print_def_path(def_id, &[])?
- } else {
- self.path_crate(cnum)?
- },
- true,
- ));
- }
+ Some(&ExternCrate { src, dependency_of, span, .. }) => match (src, dependency_of) {
+ (ExternCrateSource::Extern(def_id), LOCAL_CRATE) => {
+ debug!("try_print_visible_def_path: def_id={:?}", def_id);
+ return Ok((
+ if !span.is_dummy() {
+ self.print_def_path(def_id, &[])?
+ } else {
+ self.path_crate(cnum)?
+ },
+ true,
+ ));
+ }
+ (ExternCrateSource::Path, LOCAL_CRATE) => {
+ debug!("try_print_visible_def_path: def_id={:?}", def_id);
+ return Ok((self.path_crate(cnum)?, true));
+ }
+ _ => {}
+ },
  None => {
  return Ok((self.path_crate(cnum)?, true));
  }
- _ => {}
  }
  }