Auto merge of rust-lang#96414 - Dylan-DPC:rollup-t4ofhoa, r=Dylan-DPC

Rollup of 6 pull requests Successful merges: - rust-lang#90312 (Fix some confusing wording and improve slice-search-related docs) - rust-lang#96149 (Remove unused macro rules) - rust-lang#96279 (rustdoc: Remove .woff font files) - rust-lang#96355 (Better handle too many `#` recovery in raw str) - rust-lang#96379 (delay bug when adjusting `NeverToAny` twice during diagnostic code) - rust-lang#96384 (do not consider two extern types to be similar) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
rust-lang-ci · Apr 26, 2022 · 9ea4d41 · 9ea4d41
2 parents ec8619d f0b2dcc
commit 9ea4d41
Show file tree

Hide file tree

Showing 33 changed files with 243 additions and 176 deletions.
diff --git a/compiler/rustc_errors/src/diagnostic_builder.rs b/compiler/rustc_errors/src/diagnostic_builder.rs
@@ -255,19 255,6 @@ impl EmissionGuarantee for ! {
 /// instead of a `&DiagnosticBuilder<'a>`. This `forward!` macro makes
 /// it easy to declare such methods on the builder.
 macro_rules! forward {
- // Forward pattern for &self -> &Self
- (
- $(#[$attrs:meta])*
- pub fn $n:ident(&self, $($name:ident: $ty:ty),* $(,)?) -> &Self
- ) => {
- $(#[$attrs])*
- #[doc = concat!("See [`Diagnostic::", stringify!($n), "()`].")]
- pub fn $n(&self, $($name: $ty),*) -> &Self {
- self.diagnostic.$n($($name),*);
- self
- }
- };
-
  // Forward pattern for &mut self -> &mut Self
  (
  $(#[$attrs:meta])*

diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs
@@ -453,9 453,6 @@ macro_rules! impl_arena_allocatable_decoder {
  }
  }
  };
- ([$ignore:ident $(, $attrs:ident)*]$args:tt) => {
- impl_arena_allocatable_decoder!([$($attrs),*]$args);
- };
 }
 
 macro_rules! impl_arena_allocatable_decoders {

diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -431,10 431,11 @@ impl<'a> Parser<'a> {
  return Ok(true);
  } else if self.look_ahead(0, |t| {
  t == &token::CloseDelim(token::Brace)
- || (
- t.can_begin_expr() && t != &token::Semi && t != &token::Pound
- // Avoid triggering with too many trailing `#` in raw string.
- )
  || (t.can_begin_expr() && t != &token::Semi && t != &token::Pound)
  // Avoid triggering with too many trailing `#` in raw string.
  || (sm.is_multiline(
  self.prev_token.span.shrink_to_hi().until(self.token.span.shrink_to_lo())
  ) && t == &token::Pound)
  }) {
  // Missing semicolon typo. This is triggered if the next token could either start a
  // new statement or is a block close. For example:
@@ -508,7 509,12 @@ impl<'a> Parser<'a> {
  }
 
  if self.check_too_many_raw_str_terminators(&mut err) {
- return Err(err);
  if expected.contains(&TokenType::Token(token::Semi)) && self.eat(&token::Semi) {
  err.emit();
  return Ok(true);
  } else {
  return Err(err);
  }
  }
 
  if self.prev_token.span == DUMMY_SP {
@@ -538,22 544,41 @@ impl<'a> Parser<'a> {
  }
 
  fn check_too_many_raw_str_terminators(&mut self, err: &mut Diagnostic) -> bool {
  let sm = self.sess.source_map();
  match (&self.prev_token.kind, &self.token.kind) {
  (
  TokenKind::Literal(Lit {
  kind: LitKind::StrRaw(n_hashes) | LitKind::ByteStrRaw(n_hashes),
  ..
  }),
  TokenKind::Pound,
- ) => {
  ) if !sm.is_multiline(
  self.prev_token.span.shrink_to_hi().until(self.token.span.shrink_to_lo()),
  ) =>
  {
  let n_hashes: u8 = *n_hashes;
  err.set_primary_message("too many `#` when terminating raw string");
  let str_span = self.prev_token.span;
  let mut span = self.token.span;
  let mut count = 0;
  while self.token.kind == TokenKind::Pound
  && !sm.is_multiline(span.shrink_to_hi().until(self.token.span.shrink_to_lo()))
  {
  span = span.with_hi(self.token.span.hi());
  self.bump();
  count = 1;
  }
  err.set_span(span);
  err.span_suggestion(
- self.token.span,
- "remove the extra `#`",
  span,
  &format!("remove the extra `#`{}", pluralize!(count)),
  String::new(),
  Applicability::MachineApplicable,
  );
- err.note(&format!("the raw string started with {n_hashes} `#`s"));
  err.span_label(
  str_span,
  &format!("this raw string started with {n_hashes} `#`{}", pluralize!(n_hashes)),
  );
  true
  }
  _ => false,

diff --git a/compiler/rustc_serialize/src/serialize.rs b/compiler/rustc_serialize/src/serialize.rs
@@ -498,7 498,6 @@ macro_rules! peel {
 /// Therefore, the recursion depth is the binary logarithm of the number of
 /// tokens to count, and the expanded tree is likewise very small.
 macro_rules! count {
- () => (0usize);
  ($one:tt) => (1usize);
  ($($pairs:tt $_p:tt)*) => (count!($($pairs)*) << 1usize);
  ($odd:tt $($rest:tt)*) => (count!($($rest)*) | 1usize);

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
@@ -2249,10 2249,6 @@ impl ToJson for Target {
  let name = (stringify!($attr)).replace("_", "-");
  d.insert(name, self.$attr.to_json());
  }};
- ($attr:ident, $key_name:expr) => {{
- let name = $key_name;
- d.insert(name.into(), self.$attr.to_json());
- }};
  }
 
  macro_rules! target_option_val {

diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
@@ -1727,6 1727,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
  } else if cat_a == cat_b {
  match (a.kind(), b.kind()) {
  (ty::Adt(def_a, _), ty::Adt(def_b, _)) => def_a == def_b,
  (ty::Foreign(def_a), ty::Foreign(def_b)) => def_a == def_b,
  // Matching on references results in a lot of unhelpful
  // suggestions, so let's just not do that for now.
  //

diff --git a/compiler/rustc_typeck/src/check/expr.rs b/compiler/rustc_typeck/src/check/expr.rs
@@ -78,10 78,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  // While we don't allow *arbitrary* coercions here, we *do* allow
  // coercions from ! to `expected`.
  if ty.is_never() {
- assert!(
- !self.typeck_results.borrow().adjustments().contains_key(expr.hir_id),
- "expression with never type wound up being adjusted"
- );
  if let Some(adjustments) = self.typeck_results.borrow().adjustments().get(expr.hir_id) {
  self.tcx().sess.delay_span_bug(
  expr.span,
  "expression with never type wound up being adjusted",
  );
  return if let [Adjustment { kind: Adjust::NeverToAny, target }] = &adjustments[..] {
  target.to_owned()
  } else {
  self.tcx().ty_error()
  };
  }
 
  let adj_ty = self.next_ty_var(TypeVariableOrigin {
  kind: TypeVariableOriginKind::AdjustmentType,
  span: expr.span,

diff --git a/library/alloc/src/collections/linked_list.rs b/library/alloc/src/collections/linked_list.rs
@@ -645,7 645,7 @@ impl<T> LinkedList<T> {
  /// Returns `true` if the `LinkedList` contains an element equal to the
  /// given value.
  ///
- /// This operation should compute in *O*(*n*) time.
  /// This operation should compute linearly in *O*(*n*) time.
  ///
  /// # Examples
  ///
@@ -1569,7 1569,7 @@ impl<'a, T> CursorMut<'a, T> {
  /// Appends an element to the front of the cursor's parent list. The node
  /// that the cursor points to is unchanged, even if it is the "ghost" node.
  ///
- /// This operation should compute in O(1) time.
  /// This operation should compute in *O*(1) time.
  // `push_front` continues to point to "ghost" when it addes a node to mimic
  // the behavior of `insert_before` on an empty list.
  #[unstable(feature = "linked_list_cursors", issue = "58533")]
@@ -1584,7 1584,7 @@ impl<'a, T> CursorMut<'a, T> {
  /// Appends an element to the back of the cursor's parent list. The node
  /// that the cursor points to is unchanged, even if it is the "ghost" node.
  ///
- /// This operation should compute in O(1) time.
  /// This operation should compute in *O*(1) time.
  #[unstable(feature = "linked_list_cursors", issue = "58533")]
  pub fn push_back(&mut self, elt: T) {
  // Safety: We know that `push_back` does not change the position in
@@ -1603,7 1603,7 @@ impl<'a, T> CursorMut<'a, T> {
  /// unchanged, unless it was pointing to the front element. In that case, it
  /// points to the new front element.
  ///
- /// This operation should compute in O(1) time.
  /// This operation should compute in *O*(1) time.
  #[unstable(feature = "linked_list_cursors", issue = "58533")]
  pub fn pop_front(&mut self) -> Option<T> {
  // We can't check if current is empty, we must check the list directly.
@@ -1630,7 1630,7 @@ impl<'a, T> CursorMut<'a, T> {
  /// unchanged, unless it was pointing to the back element. In that case, it
  /// points to the "ghost" element.
  ///
- /// This operation should compute in O(1) time.
  /// This operation should compute in *O*(1) time.
  #[unstable(feature = "linked_list_cursors", issue = "58533")]
  pub fn pop_back(&mut self) -> Option<T> {
  if self.list.is_empty() {

diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
@@ -1342,6 1342,12 @@ impl<T, A: Allocator> VecDeque<T, A> {
  /// Returns `true` if the deque contains an element equal to the
  /// given value.
  ///
  /// This operation is *O*(*n*).
  ///
  /// Note that if you have a sorted `VecDeque`, [`binary_search`] may be faster.
  ///
  /// [`binary_search`]: VecDeque::binary_search
  ///
  /// # Examples
  ///
  /// ```
@@ -2560,7 2566,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
  }
  }
 
- /// Binary searches the sorted deque for a given element.
  /// Binary searches this `VecDeque` for a given element.
  /// This behaves similarly to [`contains`] if this `VecDeque` is sorted.
  ///
  /// If the value is found then [`Result::Ok`] is returned, containing the
  /// index of the matching element. If there are multiple matches, then any
@@ -2570,6 2577,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
  ///
  /// See also [`binary_search_by`], [`binary_search_by_key`], and [`partition_point`].
  ///
  /// [`contains`]: VecDeque::contains
  /// [`binary_search_by`]: VecDeque::binary_search_by
  /// [`binary_search_by_key`]: VecDeque::binary_search_by_key
  /// [`partition_point`]: VecDeque::partition_point
@@ -2614,7 2622,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
  self.binary_search_by(|e| e.cmp(x))
  }
 
- /// Binary searches the sorted deque with a comparator function.
  /// Binary searches this `VecDeque` with a comparator function.
  /// This behaves similarly to [`contains`] if this `VecDeque` is sorted.
  ///
  /// The comparator function should implement an order consistent
  /// with the sort order of the deque, returning an order code that
@@ -2629,6 2638,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
  ///
  /// See also [`binary_search`], [`binary_search_by_key`], and [`partition_point`].
  ///
  /// [`contains`]: VecDeque::contains
  /// [`binary_search`]: VecDeque::binary_search
  /// [`binary_search_by_key`]: VecDeque::binary_search_by_key
  /// [`partition_point`]: VecDeque::partition_point
@@ -2667,7 2677,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
  }
  }
 
- /// Binary searches the sorted deque with a key extraction function.
  /// Binary searches this `VecDeque` with a key extraction function.
  /// This behaves similarly to [`contains`] if this `VecDeque` is sorted.
  ///
  /// Assumes that the deque is sorted by the key, for instance with
  /// [`make_contiguous().sort_by_key()`] using the same key extraction function.
@@ -2680,6 2691,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
  ///
  /// See also [`binary_search`], [`binary_search_by`], and [`partition_point`].
  ///
  /// [`contains`]: VecDeque::contains
  /// [`make_contiguous().sort_by_key()`]: VecDeque::make_contiguous
  /// [`binary_search`]: VecDeque::binary_search
  /// [`binary_search_by`]: VecDeque::binary_search_by

diff --git a/library/core/src/internal_macros.rs b/library/core/src/internal_macros.rs
@@ -1,10 1,6 @@
 // implements the unary operator "op &T"
 // based on "op T" where T is expected to be `Copy`able
 macro_rules! forward_ref_unop {
- (impl $imp:ident, $method:ident for $t:ty) => {
- forward_ref_unop!(impl $imp, $method for $t,
- #[stable(feature = "rust1", since = "1.0.0")]);
- };
  (impl const $imp:ident, $method:ident for $t:ty) => {
  forward_ref_unop!(impl const $imp, $method for $t,
  #[stable(feature = "rust1", since = "1.0.0")]);
@@ -38,10 34,6 @@ macro_rules! forward_ref_unop {
 // implements binary operators "&T op U", "T op &U", "&T op &U"
 // based on "T op U" where T and U are expected to be `Copy`able
 macro_rules! forward_ref_binop {
- (impl $imp:ident, $method:ident for $t:ty, $u:ty) => {
- forward_ref_binop!(impl $imp, $method for $t, $u,
- #[stable(feature = "rust1", since = "1.0.0")]);
- };
  (impl const $imp:ident, $method:ident for $t:ty, $u:ty) => {
  forward_ref_binop!(impl const $imp, $method for $t, $u,
  #[stable(feature = "rust1", since = "1.0.0")]);
@@ -230,22 222,6 @@ macro_rules! cfg_if {
  }
  };
 
- // match if/else chains lacking a final `else`
- (
- if #[cfg( $i_meta:meta )] { $( $i_tokens:tt )* }
- $(
- else if #[cfg( $e_meta:meta )] { $( $e_tokens:tt )* }
- )*
- ) => {
- cfg_if! {
- @__items () ;
- (( $i_meta ) ( $( $i_tokens )* )) ,
- $(
- (( $e_meta ) ( $( $e_tokens )* )) ,
- )*
- }
- };
-
  // Internal and recursive macro to emit all the items
  //
  // Collects all the previous cfgs in a list at the beginning, so they can be

diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
@@ -2139,6 2139,12 @@ impl<T> [T] {
 
  /// Returns `true` if the slice contains an element with the given value.
  ///
  /// This operation is *O*(*n*).
  ///
  /// Note that if you have a sorted slice, [`binary_search`] may be faster.
  ///
  /// [`binary_search`]: slice::binary_search
  ///
  /// # Examples
  ///
  /// ```
@@ -2298,7 2304,8 @@ impl<T> [T] {
  None
  }
 
- /// Binary searches this sorted slice for a given element.
  /// Binary searches this slice for a given element.
  /// This behaves similary to [`contains`] if this slice is sorted.
  ///
  /// If the value is found then [`Result::Ok`] is returned, containing the
  /// index of the matching element. If there are multiple matches, then any
@@ -2310,6 2317,7 @@ impl<T> [T] {
  ///
  /// See also [`binary_search_by`], [`binary_search_by_key`], and [`partition_point`].
  ///
  /// [`contains`]: slice::contains
  /// [`binary_search_by`]: slice::binary_search_by
  /// [`binary_search_by_key`]: slice::binary_search_by_key
  /// [`partition_point`]: slice::partition_point
@@ -2349,7 2357,8 @@ impl<T> [T] {
  self.binary_search_by(|p| p.cmp(x))
  }
 
- /// Binary searches this sorted slice with a comparator function.
  /// Binary searches this slice with a comparator function.
  /// This behaves similarly to [`contains`] if this slice is sorted.
  ///
  /// The comparator function should implement an order consistent
  /// with the sort order of the underlying slice, returning an
@@ -2366,6 2375,7 @@ impl<T> [T] {
  ///
  /// See also [`binary_search`], [`binary_search_by_key`], and [`partition_point`].
  ///
  /// [`contains`]: slice::contains
  /// [`binary_search`]: slice::binary_search
  /// [`binary_search_by_key`]: slice::binary_search_by_key
  /// [`partition_point`]: slice::partition_point
@@ -2424,7 2434,8 @@ impl<T> [T] {
  Err(left)
  }
 
- /// Binary searches this sorted slice with a key extraction function.
  /// Binary searches this slice with a key extraction function.
  /// This behaves similarly to [`contains`] if this slice is sorted.
  ///
  /// Assumes that the slice is sorted by the key, for instance with
  /// [`sort_by_key`] using the same key extraction function.
@@ -2439,6 2450,7 @@ impl<T> [T] {
  ///
  /// See also [`binary_search`], [`binary_search_by`], and [`partition_point`].
  ///
  /// [`contains`]: slice::contains
  /// [`sort_by_key`]: slice::sort_by_key
  /// [`binary_search`]: slice::binary_search
  /// [`binary_search_by`]: slice::binary_search_by

diff --git a/library/core/tests/num/ops.rs b/library/core/tests/num/ops.rs
@@ -43,18 43,6 @@ macro_rules! impls_defined {
 }
 
 macro_rules! test_op {
- ($fn_name:ident, $op:ident::$method:ident($lhs:literal, $rhs:literal), $result:literal, $($t:ty), ) => {
- #[test]
- fn $fn_name() {
- impls_defined!($op, $method($lhs, $rhs), $result, $($t), );
- }
- };
- ($fn_name:ident, $op:ident::$method:ident(&mut $lhs:literal, $rhs:literal), $result:literal, $($t:ty), ) => {
- #[test]
- fn $fn_name() {
- impls_defined!($op, $method(&mut $lhs, $rhs), $result, $($t), );
- }
- };
  ($fn_name:ident, $op:ident::$method:ident($lhs:literal), $result:literal, $($t:ty), ) => {
  #[test]
  fn $fn_name() {