Rollup of 8 pull requests

Cargo.lock

@@ -465,6 +465,7 @@ dependencies = [
  "termcolor",
  "toml_edit",
  "url 2.2.2",
+ "winapi",
 ]
 
 [[package]]
@@ -2655,9 +2656,9 @@ checksum = "dd20eec3dbe4376829cb7d80ae6ac45e0a766831dca50202ff2d40db46a8a024"
 
 [[package]]
 name = "os_info"
-version = "3.4.0"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eca3ecae1481e12c3d9379ec541b238a16f0b75c9a409942daa8ec20dbfdb62"
+checksum = "5209b2162b2c140df493a93689e04f8deab3a67634f5bc7a553c0a98e5b8d399"
 dependencies = [
  "log",
  "serde",

compiler/rustc_ast_lowering/src/lib.rs

@@ -220,7 +220,20 @@ impl ResolverAstLoweringExt for ResolverAstLowering {
  }
 
  fn get_remapped_def_id(&self, mut local_def_id: LocalDefId) -> LocalDefId {
- for map in &self.generics_def_id_map {
+ // `generics_def_id_map` is a stack of mappings. As we go deeper in impl traits nesting we
+ // push new mappings so we need to try first the latest mappings, hence `iter().rev()`.
+ //
+ // Consider:
+ //
+ // `fn test<'a, 'b>() -> impl Trait<&'a u8, Ty = impl Sized + 'b> {}`
+ //
+ // We would end with a generics_def_id_map like:
+ //
+ // `[[fn#'b -> impl_trait#'b], [fn#'b -> impl_sized#'b]]`
+ //
+ // for the opaque type generated on `impl Sized + 'b`, We want the result to be:
+ // impl_sized#'b, so iterating forward is the wrong thing to do.
+ for map in self.generics_def_id_map.iter().rev() {
  if let Some(r) = map.get(&local_def_id) {
  debug!("def_id_remapper: remapping from `{local_def_id:?}` to `{r:?}`");
  local_def_id = *r;

compiler/rustc_errors/src/lib.rs

@@ -4,7 +4,6 @@
 
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![feature(drain_filter)]
-#![feature(backtrace)]
 #![feature(if_let_guard)]
 #![cfg_attr(bootstrap, feature(let_chains))]
 #![feature(let_else)]

compiler/rustc_metadata/src/native_libs.rs

@@ -328,7 +328,31 @@ impl<'tcx> Collector<'tcx> {
  .map(|child_item| self.build_dll_import(abi, child_item))
  .collect()
  }
- _ => Vec::new(),
+ _ => {
+ for child_item in foreign_mod_items {
+ if self.tcx.def_kind(child_item.id.def_id).has_codegen_attrs()
+ && self
+ .tcx
+ .codegen_fn_attrs(child_item.id.def_id)
+ .link_ordinal
+ .is_some()
+ {
+ let link_ordinal_attr = self
+ .tcx
+ .hir()
+ .attrs(self.tcx.hir().local_def_id_to_hir_id(child_item.id.def_id))
+ .iter()
+ .find(|a| a.has_name(sym::link_ordinal))
+ .unwrap();
+ sess.span_err(
+ link_ordinal_attr.span,
+ "`#[link_ordinal]` is only supported if link kind is `raw-dylib`",
+ );
+ }
+ }
+
+ Vec::new()
+ }
  };
  self.libs.push(NativeLib {
  name: name.map(|(name, _)| name),

compiler/rustc_middle/src/lib.rs

@@ -26,7 +26,6 @@
 #![feature(allocator_api)]
 #![feature(array_windows)]
 #![feature(assert_matches)]
-#![feature(backtrace)]
 #![feature(box_patterns)]
 #![feature(core_intrinsics)]
 #![feature(discriminant_kind)]

compiler/rustc_parse/src/parser/expr.rs

@@ -1258,8 +1258,11 @@ impl<'a> Parser<'a> {
 
  /// Parse an indexing expression `expr[...]`.
  fn parse_index_expr(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>> {
+ let prev_span = self.prev_token.span;
+ let open_delim_span = self.token.span;
  self.bump(); // `[`
  let index = self.parse_expr()?;
+ self.suggest_missing_semicolon_before_array(prev_span, open_delim_span)?;
  self.expect(&token::CloseDelim(Delimiter::Bracket))?;
  Ok(self.mk_expr(lo.to(self.prev_token.span), self.mk_index(base, index), AttrVec::new()))
  }
@@ -2056,6 +2059,45 @@ impl<'a> Parser<'a> {
  }
  }
 
+ fn suggest_missing_semicolon_before_array(
+ &self,
+ prev_span: Span,
+ open_delim_span: Span,
+ ) -> PResult<'a, ()> {
+ if self.token.kind == token::Comma {
+ let mut snapshot = self.create_snapshot_for_diagnostic();
+ snapshot.bump();
+ match snapshot.parse_seq_to_before_end(
+ &token::CloseDelim(Delimiter::Bracket),
+ SeqSep::trailing_allowed(token::Comma),
+ |p| p.parse_expr(),
+ ) {
+ Ok(_)
+ // When the close delim is `)`, `token.kind` is expected to be `token::CloseDelim(Delimiter::Parenthesis)`,
+ // but the actual `token.kind` is `token::CloseDelim(Delimiter::Bracket)`.
+ // This is because the `token.kind` of the close delim is treated as the same as
+ // that of the open delim in `TokenTreesReader::parse_token_tree`, even if the delimiters of them are different.
+ // Therefore, `token.kind` should not be compared here.
+ if snapshot
+ .span_to_snippet(snapshot.token.span)
+ .map_or(false, |snippet| snippet == "]") =>
+ {
+ let mut err = self.struct_span_err(open_delim_span, "expected `;`, found `[`");
+ err.span_suggestion_verbose(
+ prev_span.shrink_to_hi(),
+ "consider adding `;` here",
+ ';',
+ Applicability::MaybeIncorrect,
+ );
+ return Err(err);
+ }
+ Ok(_) => (),
+ Err(err) => err.cancel(),
+ }
+ }
+ Ok(())
+ }
+
  /// Parses a block or unsafe block.
  pub(super) fn parse_block_expr(
  &mut self,

library/core/benches/num/int_log/mod.rs

@@ -9,7 +9,7 @@ macro_rules! int_log_bench {
  for n in 0..(<$t>::BITS / 8) {
  for i in 1..=(100 as $t) {
  let x = black_box(i << (n * 8));
- black_box(x.log10());
+ black_box(x.ilog10());
  }
  }
  });
@@ -27,7 +27,7 @@ macro_rules! int_log_bench {
  .collect();
  bench.iter(|| {
  for x in &numbers {
- black_box(black_box(x).log10());
+ black_box(black_box(x).ilog10());
  }
  });
  }
@@ -44,7 +44,7 @@ macro_rules! int_log_bench {
  .collect();
  bench.iter(|| {
  for x in &numbers {
- black_box(black_box(x).log10());
+ black_box(black_box(x).ilog10());
  }
  });
  }

library/core/src/char/methods.rs

@@ -892,8 +892,7 @@ impl char {
  ///
  /// The general categories for numbers (`Nd` for decimal digits, `Nl` for letter-like numeric
  /// characters, and `No` for other numeric characters) are specified in the [Unicode Character
- /// Database][ucd] [`UnicodeData.txt`]. Note that this means ideographic numbers like '三'
- /// are considered alphabetic, not numeric. Please consider to use `is_ascii_digit` or `is_digit`.
+ /// Database][ucd] [`UnicodeData.txt`].
  ///
  /// This method doesn't cover everything that could be considered a number, e.g. ideographic numbers like '三'.
  /// If you want everything including characters with overlapping purposes then you might want to use

library/core/src/num/bignum.rs

@@ -137,7 +137,7 @@ macro_rules! define_bignum {
  // Find the most significant non-zero digit.
  let msd = digits.iter().rposition(|&x| x != 0);
  match msd {
- Some(msd) => msd * digitbits + digits[msd].log2() as usize + 1,
+ Some(msd) => msd * digitbits + digits[msd].ilog2() as usize + 1,
  // There are no non-zero digits, i.e., the number is zero.
  _ => 0,
  }

library/core/src/num/int_macros.rs

@@ -2204,7 +2204,7 @@ macro_rules! int_impl {
  /// rounded down.
  ///
  /// This method might not be optimized owing to implementation details;
- /// `log2` can produce results more efficiently for base 2, and `log10`
+ /// `ilog2` can produce results more efficiently for base 2, and `ilog10`
  /// can produce results more efficiently for base 10.
  ///
  /// # Panics
@@ -2217,7 +2217,7 @@ macro_rules! int_impl {
  ///
  /// ```
  /// #![feature(int_log)]
- #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".log(5), 1);")]
+ #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".ilog(5), 1);")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
@@ -2226,8 +2226,8 @@ macro_rules! int_impl {
  #[track_caller]
  #[rustc_inherit_overflow_checks]
  #[allow(arithmetic_overflow)]
- pub const fn log(self, base: Self) -> u32 {
- match self.checked_log(base) {
+ pub const fn ilog(self, base: Self) -> u32 {
+ match self.checked_ilog(base) {
  Some(n) => n,
  None => {
  // In debug builds, trigger a panic on None.
@@ -2250,7 +2250,7 @@ macro_rules! int_impl {
  ///
  /// ```
  /// #![feature(int_log)]
- #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".log2(), 1);")]
+ #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".ilog2(), 1);")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
@@ -2259,8 +2259,8 @@ macro_rules! int_impl {
  #[track_caller]
  #[rustc_inherit_overflow_checks]
  #[allow(arithmetic_overflow)]
- pub const fn log2(self) -> u32 {
- match self.checked_log2() {
+ pub const fn ilog2(self) -> u32 {
+ match self.checked_ilog2() {
  Some(n) => n,
  None => {
  // In debug builds, trigger a panic on None.
@@ -2283,7 +2283,7 @@ macro_rules! int_impl {
  ///
  /// ```
  /// #![feature(int_log)]
- #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".log10(), 1);")]
+ #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".ilog10(), 1);")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
@@ -2292,8 +2292,8 @@ macro_rules! int_impl {
  #[track_caller]
  #[rustc_inherit_overflow_checks]
  #[allow(arithmetic_overflow)]
- pub const fn log10(self) -> u32 {
- match self.checked_log10() {
+ pub const fn ilog10(self) -> u32 {
+ match self.checked_ilog10() {
  Some(n) => n,
  None => {
  // In debug builds, trigger a panic on None.
@@ -2311,20 +2311,20 @@ macro_rules! int_impl {
  /// Returns `None` if the number is negative or zero, or if the base is not at least 2.
  ///
  /// This method might not be optimized owing to implementation details;
- /// `checked_log2` can produce results more efficiently for base 2, and
- /// `checked_log10` can produce results more efficiently for base 10.
+ /// `checked_ilog2` can produce results more efficiently for base 2, and
+ /// `checked_ilog10` can produce results more efficiently for base 10.
  ///
  /// # Examples
  ///
  /// ```
  /// #![feature(int_log)]
- #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_log(5), Some(1));")]
+ #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_ilog(5), Some(1));")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
  without modifying the original"]
  #[inline]
- pub const fn checked_log(self, base: Self) -> Option<u32> {
+ pub const fn checked_ilog(self, base: Self) -> Option<u32> {
  if self <= 0 || base <= 1 {
  None
  } else {
@@ -2333,7 +2333,7 @@ macro_rules! int_impl {
 
  // Optimization for 128 bit wide integers.
  if Self::BITS == 128 {
- let b = Self::log2(self) / (Self::log2(base) + 1);
+ let b = Self::ilog2(self) / (Self::ilog2(base) + 1);
  n += b;
  r /= base.pow(b as u32);
  }
@@ -2354,13 +2354,13 @@ macro_rules! int_impl {
  ///
  /// ```
  /// #![feature(int_log)]
- #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_log2(), Some(1));")]
+ #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_ilog2(), Some(1));")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
  without modifying the original"]
  #[inline]
- pub const fn checked_log2(self) -> Option<u32> {
+ pub const fn checked_ilog2(self) -> Option<u32> {
  if self <= 0 {
  None
  } else {
@@ -2378,13 +2378,13 @@ macro_rules! int_impl {
  ///
  /// ```
  /// #![feature(int_log)]
- #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_log10(), Some(1));")]
+ #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_ilog10(), Some(1));")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
  without modifying the original"]
  #[inline]
- pub const fn checked_log10(self) -> Option<u32> {
+ pub const fn checked_ilog10(self) -> Option<u32> {
  if self > 0 {
  Some(int_log10::$ActualT(self as $ActualT))
  } else {

library/core/src/num/nonzero.rs

@@ -450,7 +450,7 @@ macro_rules! nonzero_unsigned_operations {
  /// Returns the base 2 logarithm of the number, rounded down.
  ///
  /// This is the same operation as
- #[doc = concat!("[`", stringify!($Int), "::log2`],")]
+ #[doc = concat!("[`", stringify!($Int), "::ilog2`],")]
  /// except that it has no failure cases to worry about
  /// since this value can never be zero.
  ///
@@ -460,22 +460,22 @@ macro_rules! nonzero_unsigned_operations {
  /// #![feature(int_log)]
  #[doc = concat!("# use std::num::", stringify!($Ty), ";")]
  ///
- #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(7).unwrap().log2(), 2);")]
- #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(8).unwrap().log2(), 3);")]
- #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(9).unwrap().log2(), 3);")]
+ #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(7).unwrap().ilog2(), 2);")]
+ #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(8).unwrap().ilog2(), 3);")]
+ #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(9).unwrap().ilog2(), 3);")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
  without modifying the original"]
  #[inline]
- pub const fn log2(self) -> u32 {
+ pub const fn ilog2(self) -> u32 {
  Self::BITS - 1 - self.leading_zeros()
  }
 
  /// Returns the base 10 logarithm of the number, rounded down.
  ///
  /// This is the same operation as
- #[doc = concat!("[`", stringify!($Int), "::log10`],")]
+ #[doc = concat!("[`", stringify!($Int), "::ilog10`],")]
  /// except that it has no failure cases to worry about
  /// since this value can never be zero.
  ///
@@ -485,15 +485,15 @@ macro_rules! nonzero_unsigned_operations {
  /// #![feature(int_log)]
  #[doc = concat!("# use std::num::", stringify!($Ty), ";")]
  ///
- #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(99).unwrap().log10(), 1);")]
- #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(100).unwrap().log10(), 2);")]
- #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(101).unwrap().log10(), 2);")]
+ #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(99).unwrap().ilog10(), 1);")]
+ #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(100).unwrap().ilog10(), 2);")]
+ #[doc = concat!("assert_eq!(", stringify!($Ty), "::new(101).unwrap().ilog10(), 2);")]
  /// ```
  #[unstable(feature = "int_log", issue = "70887")]
  #[must_use = "this returns the result of the operation, \
  without modifying the original"]
  #[inline]
- pub const fn log10(self) -> u32 {
+ pub const fn ilog10(self) -> u32 {
  super::int_log10::$Int(self.0)
  }
  }