Rollup of 15 pull requests

compiler/rustc_ast_lowering/src/lib.rs

@@ -507,7 +507,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
  let count = generics
  .params
  .iter()
- .filter(|param| matches!(param.kind, ast::GenericParamKind::Lifetime { .. }))
+ .filter(|param| {
+ matches!(param.kind, ast::GenericParamKind::Lifetime { .. })
+ })
  .count();
  self.lctx.type_def_lifetime_params.insert(def_id.to_def_id(), count);
  }

compiler/rustc_attr/src/builtin.rs

@@ -586,12 +586,14 @@ pub fn eval_condition(
  return false;
  }
  };
- let channel = env!("CFG_RELEASE_CHANNEL");
- let nightly = channel == "nightly" || channel == "dev";
  let rustc_version = parse_version(env!("CFG_RELEASE"), true).unwrap();
 
- // See https://github.com/rust-lang/rust/issues/64796#issuecomment-625474439 for details
- if nightly { rustc_version > min_version } else { rustc_version >= min_version }
+ // See https://github.com/rust-lang/rust/issues/64796#issuecomment-640851454 for details
+ if sess.assume_incomplete_release {
+ rustc_version > min_version
+ } else {
+ rustc_version >= min_version
+ }
  }
  ast::MetaItemKind::List(ref mis) => {
  for mi in mis.iter() {

compiler/rustc_builtin_macros/src/deriving/generic/mod.rs

@@ -598,7 +598,7 @@ impl<'a> TraitDef<'a> {
 
  let mut ty_params = params
  .iter()
- .filter(|param| matches!(param.kind,  ast::GenericParamKind::Type{..}))
+ .filter(|param| matches!(param.kind, ast::GenericParamKind::Type { .. }))
  .peekable();
 
  if ty_params.peek().is_some() {

compiler/rustc_errors/src/diagnostic_builder.rs

@@ -36,7 +36,7 @@ macro_rules! forward_inner_docs {
  ($e:expr => $i:item) => {
  #[doc = $e]
  $i
- }
+ };
 }
 
 /// In general, the `DiagnosticBuilder` uses deref to allow access to

compiler/rustc_errors/src/snippet.rs

@@ -122,11 +122,13 @@ impl Annotation {
  }
 
  pub fn is_multiline(&self) -> bool {
- matches!(self.annotation_type,
+ matches!(
+ self.annotation_type,
  AnnotationType::Multiline(_)
- | AnnotationType::MultilineStart(_)
- | AnnotationType::MultilineLine(_)
- | AnnotationType::MultilineEnd(_))
+ | AnnotationType::MultilineStart(_)
+ | AnnotationType::MultilineLine(_)
+ | AnnotationType::MultilineEnd(_)
+ )
  }
 
  pub fn len(&self) -> usize {
@@ -158,7 +160,10 @@ impl Annotation {
 
  pub fn takes_space(&self) -> bool {
  // Multiline annotations always have to keep vertical space.
- matches!(self.annotation_type, AnnotationType::MultilineStart(_) | AnnotationType::MultilineEnd(_))
+ matches!(
+ self.annotation_type,
+ AnnotationType::MultilineStart(_) | AnnotationType::MultilineEnd(_)
+ )
  }
 }
 

compiler/rustc_hir/src/hir.rs

@@ -1543,10 +1543,10 @@ pub fn is_range_literal(expr: &Expr<'_>) -> bool {
  **qpath,
  QPath::LangItem(
  LangItem::Range
- | LangItem::RangeTo
- | LangItem::RangeFrom
- | LangItem::RangeFull
- | LangItem::RangeToInclusive,
+  | LangItem::RangeTo
+  | LangItem::RangeFrom
+  | LangItem::RangeFull
+  | LangItem::RangeToInclusive,
  _,
  )
  ),

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/trait_impl_difference.rs

@@ -132,7 +132,12 @@ impl Visitor<'tcx> for TypeParamSpanVisitor<'tcx> {
  [segment]
  if segment
  .res
- .map(|res| matches!(res, Res::SelfTy(_, _) | Res::Def(hir::def::DefKind::TyParam, _)))
+ .map(|res| {
+ matches!(
+ res,
+ Res::SelfTy(_, _) | Res::Def(hir::def::DefKind::TyParam, _)
+ )
+ })
  .unwrap_or(false) =>
  {
  self.types.push(path.span);

compiler/rustc_interface/src/tests.rs

@@ -540,6 +540,7 @@ fn test_debugging_options_tracking_hash() {
  // This list is in alphabetical order.
  tracked!(allow_features, Some(vec![String::from("lang_items")]));
  tracked!(always_encode_mir, true);
+ tracked!(assume_incomplete_release, true);
  tracked!(asm_comments, true);
  tracked!(binary_dep_depinfo, true);
  tracked!(chalk, true);

compiler/rustc_middle/src/hir/map/mod.rs

@@ -559,9 +559,9 @@ impl<'hir> Map<'hir> {
  self.find(self.get_parent_node(id)),
  Some(
  Node::Item(_)
- | Node::TraitItem(_)
- | Node::ImplItem(_)
- | Node::Expr(Expr { kind: ExprKind::Closure(..), .. }),
+  | Node::TraitItem(_)
+  | Node::ImplItem(_)
+  | Node::Expr(Expr { kind: ExprKind::Closure(..), .. }),
  )
  )
  }

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -588,12 +588,3 @@ pub fn read_target_uint(endianness: Endian, mut source: &[u8]) -> Result<u128, i
  debug_assert!(source.len() == 0); // We should have consumed the source buffer.
  uint
 }
-
-/// Computes the unsigned absolute value without wrapping or panicking.
-#[inline]
-pub fn uabs(value: i64) -> u64 {
- // The only tricky part here is if value == i64::MIN. In that case,
- // wrapping_abs() returns i64::MIN == -2^63. Casting this value to a u64
- // gives 2^63, the correct value.
- value.wrapping_abs() as u64
-}

compiler/rustc_middle/src/mir/interpret/pointer.rs

@@ -1,4 +1,4 @@
-use super::{uabs, AllocId, InterpResult};
+use super::{AllocId, InterpResult};
 
 use rustc_macros::HashStable;
 use rustc_target::abi::{HasDataLayout, Size};
@@ -57,7 +57,7 @@ pub trait PointerArithmetic: HasDataLayout {
  #[inline]
  fn overflowing_signed_offset(&self, val: u64, i: i64) -> (u64, bool) {
  // We need to make sure that i fits in a machine isize.
- let n = uabs(i);
+ let n = i.unsigned_abs();
  if i >= 0 {
  let (val, over) = self.overflowing_offset(val, n);
  (val, over || i > self.machine_isize_max())

compiler/rustc_middle/src/mir/mod.rs

@@ -962,8 +962,7 @@ impl<'tcx> LocalDecl<'tcx> {
  opt_ty_info: _,
  opt_match_place: _,
  pat_span: _,
- })
- | BindingForm::ImplicitSelf(ImplicitSelfKind::Imm),
+ }) | BindingForm::ImplicitSelf(ImplicitSelfKind::Imm),
  )))
  )
  }
@@ -980,8 +979,7 @@ impl<'tcx> LocalDecl<'tcx> {
  opt_ty_info: _,
  opt_match_place: _,
  pat_span: _,
- })
- | BindingForm::ImplicitSelf(_),
+ }) | BindingForm::ImplicitSelf(_),
  )))
  )
  }

compiler/rustc_middle/src/ty/diagnostics.rs

@@ -12,13 +12,17 @@ impl<'tcx> TyS<'tcx> {
  pub fn is_primitive_ty(&self) -> bool {
  matches!(
  self.kind(),
- Bool | Char | Str | Int(_) | Uint(_) | Float(_)
- | Infer(
- InferTy::IntVar(_)
- | InferTy::FloatVar(_)
- | InferTy::FreshIntTy(_)
- | InferTy::FreshFloatTy(_)
- )
+ Bool | Char
+ | Str
+ | Int(_)
+ | Uint(_)
+ | Float(_)
+ | Infer(
+ InferTy::IntVar(_)
+ | InferTy::FloatVar(_)
+ | InferTy::FreshIntTy(_)
+ | InferTy::FreshFloatTy(_)
+ )
  )
  }
 

compiler/rustc_middle/src/ty/error.rs

@@ -646,11 +646,14 @@ impl<T> Trait<T> for X {
  let current_method_ident = body_owner.and_then(|n| n.ident()).map(|i| i.name);
 
  // We don't want to suggest calling an assoc fn in a scope where that isn't feasible.
- let callable_scope = matches!(body_owner, Some(
+ let callable_scope = matches!(
+ body_owner,
+ Some(
  hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(..), .. })
- | hir::Node::TraitItem(hir::TraitItem { kind: hir::TraitItemKind::Fn(..), .. })
- | hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Fn(..), .. }),
- ));
+ | hir::Node::TraitItem(hir::TraitItem { kind: hir::TraitItemKind::Fn(..), .. })
+ | hir::Node::ImplItem(hir::ImplItem { kind: hir::ImplItemKind::Fn(..), .. }),
+ )
+ );
  let impl_comparison = matches!(
  cause_code,
  ObligationCauseCode::CompareImplMethodObligation { .. }

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2143,6 +2143,7 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N
 
  match child.res {
  def::Res::Def(DefKind::AssocTy, _) => {}
+ def::Res::Def(DefKind::TyAlias, _) => {}
  def::Res::Def(defkind, def_id) => {
  if let Some(ns) = defkind.ns() {
  collect_fn(&child.ident, ns, def_id);

compiler/rustc_middle/src/ty/sty.rs

@@ -1871,8 +1871,14 @@ impl<'tcx> TyS<'tcx> {
  pub fn is_scalar(&self) -> bool {
  matches!(
  self.kind(),
- Bool | Char | Int(_) | Float(_) | Uint(_) | FnDef(..) | FnPtr(_) | RawPtr(_)
- | Infer(IntVar(_) | FloatVar(_))
+ Bool | Char
+ | Int(_)
+ | Float(_)
+ | Uint(_)
+ | FnDef(..)
+ | FnPtr(_)
+ | RawPtr(_)
+ | Infer(IntVar(_) | FloatVar(_))
  )
  }
 

compiler/rustc_mir/src/interpret/intrinsics.rs

@@ -7,7 +7,7 @@ use std::convert::TryFrom;
 use rustc_hir::def_id::DefId;
 use rustc_middle::mir::{
  self,
- interpret::{uabs, ConstValue, GlobalId, InterpResult, Scalar},
+ interpret::{ConstValue, GlobalId, InterpResult, Scalar},
  BinOp,
 };
 use rustc_middle::ty;
@@ -542,7 +542,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  // memory between these pointers must be accessible. Note that we do not require the
  // pointers to be properly aligned (unlike a read/write operation).
  let min_ptr = if offset_bytes >= 0 { ptr } else { offset_ptr };
- let size: u64 = uabs(offset_bytes);
+ let size = offset_bytes.unsigned_abs();
  // This call handles checking for integer/NULL pointers.
  self.memory.check_ptr_access_align(
  min_ptr,