Rollup of 7 pull requests

compiler/rustc_ast_lowering/src/item.rs

@@ -908,11 +908,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
  |this| match ty {
  None => {
  let ty = this.arena.alloc(this.ty(i.span, hir::TyKind::Err));
- hir::ImplItemKind::TyAlias(ty)
+ hir::ImplItemKind::Type(ty)
  }
  Some(ty) => {
  let ty = this.lower_ty(ty, &ImplTraitContext::TypeAliasesOpaqueTy);
- hir::ImplItemKind::TyAlias(ty)
+ hir::ImplItemKind::Type(ty)
  }
  },
  )

compiler/rustc_hir/src/hir.rs

@@ -2315,7 +2315,7 @@ pub enum ImplItemKind<'hir> {
  /// An associated function implementation with the given signature and body.
  Fn(FnSig<'hir>, BodyId),
  /// An associated type.
- TyAlias(&'hir Ty<'hir>),
+ Type(&'hir Ty<'hir>),
 }
 
 // The name of the associated type for `Fn` return types.

compiler/rustc_hir/src/intravisit.rs

@@ -979,7 +979,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt
  impl_item.hir_id(),
  );
  }
- ImplItemKind::TyAlias(ref ty) => {
+ ImplItemKind::Type(ref ty) => {
  visitor.visit_id(impl_item.hir_id());
  visitor.visit_ty(ty);
  }

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1062,7 +1062,7 @@ fn check_impl_items_against_trait<'tcx>(
  opt_trait_span,
  );
  }
- hir::ImplItemKind::TyAlias(impl_ty) => {
+ hir::ImplItemKind::Type(impl_ty) => {
  let opt_trait_span = tcx.hir().span_if_local(ty_trait_item.def_id);
  compare_ty_impl(
  tcx,

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -837,7 +837,7 @@ fn check_impl_item(tcx: TyCtxt<'_>, impl_item: &hir::ImplItem<'_>) {
  let (method_sig, span) = match impl_item.kind {
  hir::ImplItemKind::Fn(ref sig, _) => (Some(sig), impl_item.span),
  // Constrain binding and overflow error spans to `<Ty>` in `type foo = <Ty>`.
- hir::ImplItemKind::TyAlias(ty) if ty.span != DUMMY_SP => (None, ty.span),
+ hir::ImplItemKind::Type(ty) if ty.span != DUMMY_SP => (None, ty.span),
  _ => (None, impl_item.span),
  };
 

compiler/rustc_hir_analysis/src/collect.rs

@@ -738,7 +738,7 @@ fn convert_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::ImplItemId) {
  hir::ImplItemKind::Fn(..) => {
  tcx.ensure().fn_sig(def_id);
  }
- hir::ImplItemKind::TyAlias(_) => {
+ hir::ImplItemKind::Type(_) => {
  // Account for `type T = _;`
  let mut visitor = HirPlaceholderCollector::default();
  visitor.visit_impl_item(impl_item);

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -213,7 +213,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
  Node::TraitItem(item) if matches!(item.kind, TraitItemKind::Type(..)) => {
  (None, Defaults::Deny)
  }
- Node::ImplItem(item) if matches!(item.kind, ImplItemKind::TyAlias(..)) => {
+ Node::ImplItem(item) if matches!(item.kind, ImplItemKind::Type(..)) => {
  (None, Defaults::Deny)
  }
 

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -284,7 +284,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
  icx.to_ty(ty)
  }
  }
- ImplItemKind::TyAlias(ty) => {
+ ImplItemKind::Type(ty) => {
  if tcx.impl_trait_ref(tcx.hir().get_parent_item(hir_id)).is_none() {
  check_feature_inherent_assoc_ty(tcx, item.span);
  }

compiler/rustc_hir_analysis/src/hir_wf_check.rs

@@ -117,7 +117,7 @@ fn diagnostic_hir_wf_check<'tcx>(
  let ty = match loc {
  WellFormedLoc::Ty(_) => match hir.get(hir_id) {
  hir::Node::ImplItem(item) => match item.kind {
- hir::ImplItemKind::TyAlias(ty) => Some(ty),
+ hir::ImplItemKind::Type(ty) => Some(ty),
  hir::ImplItemKind::Const(ty, _) => Some(ty),
  ref item => bug!("Unexpected ImplItem {:?}", item),
  },

compiler/rustc_hir_pretty/src/lib.rs

@@ -887,7 +887,7 @@ impl<'a> State<'a> {
  self.end(); // need to close a box
  self.ann.nested(self, Nested::Body(body));
  }
- hir::ImplItemKind::TyAlias(ty) => {
+ hir::ImplItemKind::Type(ty) => {
  self.print_associated_type(ii.ident, ii.generics, None, Some(ty));
  }
  }

compiler/rustc_incremental/src/persist/dirty_clean.rs

@@ -302,7 +302,7 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
  HirNode::ImplItem(item) => match item.kind {
  ImplItemKind::Fn(..) => ("Node::ImplItem", LABELS_FN_IN_IMPL),
  ImplItemKind::Const(..) => ("NodeImplConst", LABELS_CONST_IN_IMPL),
- ImplItemKind::TyAlias(..) => ("NodeImplType", LABELS_CONST_IN_IMPL),
+ ImplItemKind::Type(..) => ("NodeImplType", LABELS_CONST_IN_IMPL),
  },
  _ => self.tcx.sess.span_fatal(
  attr.span,

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -2598,7 +2598,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  for h in self.tcx.hir().parent_iter(param.hir_id) {
  break 'origin match h.1 {
  Node::ImplItem(hir::ImplItem {
- kind: hir::ImplItemKind::TyAlias(..),
+ kind: hir::ImplItemKind::Type(..),
  generics,
  ..
  })

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

@@ -241,7 +241,7 @@ impl<'hir> Map<'hir> {
  Node::ImplItem(item) => match item.kind {
  ImplItemKind::Const(..) => DefKind::AssocConst,
  ImplItemKind::Fn(..) => DefKind::AssocFn,
- ImplItemKind::TyAlias(..) => DefKind::AssocTy,
+ ImplItemKind::Type(..) => DefKind::AssocTy,
  },
  Node::Variant(_) => DefKind::Variant,
  Node::Ctor(variant_data) => {
@@ -1244,7 +1244,7 @@ fn hir_id_to_string(map: Map<'_>, id: HirId) -> String {
  format!("assoc const {} in {}{}", ii.ident, path_str(), id_str)
  }
  ImplItemKind::Fn(..) => format!("method {} in {}{}", ii.ident, path_str(), id_str),
- ImplItemKind::TyAlias(_) => {
+ ImplItemKind::Type(_) => {
  format!("assoc type {} in {}{}", ii.ident, path_str(), id_str)
  }
  },

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -491,7 +491,7 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
  ],
  Applicability::HasPlaceholders,
  );
- if !bindings.is_empty() && cx.tcx.sess.is_nightly_build() {
+ if !bindings.is_empty() {
  err.span_suggestion_verbose(
  semi_span.shrink_to_lo(),
  &format!(

compiler/rustc_passes/src/check_attr.rs

@@ -49,7 +49,7 @@ pub(crate) fn target_from_impl_item<'tcx>(
  Target::Method(MethodKind::Inherent)
  }
  }
- hir::ImplItemKind::TyAlias(..) => Target::AssocTy,
+ hir::ImplItemKind::Type(..) => Target::AssocTy,
  }
 }
 

compiler/rustc_passes/src/hir_stats.rs

@@ -391,7 +391,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> {
  fn visit_impl_item(&mut self, ii: &'v hir::ImplItem<'v>) {
  record_variants!(
  (self, ii, ii.kind, Id::Node(ii.hir_id()), hir, ImplItem, ImplItemKind),
- [Const, Fn, TyAlias]
+ [Const, Fn, Type]
  );
  hir_visit::walk_impl_item(self, ii)
  }

compiler/rustc_passes/src/reachable.rs

@@ -155,7 +155,7 @@ impl<'tcx> ReachableContext<'tcx> {
  let impl_did = self.tcx.hir().get_parent_item(hir_id);
  method_might_be_inlined(self.tcx, impl_item, impl_did.def_id)
  }
- hir::ImplItemKind::TyAlias(_) => false,
+ hir::ImplItemKind::Type(_) => false,
  },
  Some(_) => false,
  None => false, // This will happen for default methods.
@@ -271,7 +271,7 @@ impl<'tcx> ReachableContext<'tcx> {
  self.visit_nested_body(body)
  }
  }
- hir::ImplItemKind::TyAlias(_) => {}
+ hir::ImplItemKind::Type(_) => {}
  },
  Node::Expr(&hir::Expr {
  kind: hir::ExprKind::Closure(&hir::Closure { body, .. }),

compiler/rustc_privacy/src/lib.rs

@@ -1574,7 +1574,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
  hir::ImplItemKind::Const(..) | hir::ImplItemKind::Fn(..) => {
  self.access_levels.is_reachable(impl_item_ref.id.def_id.def_id)
  }
- hir::ImplItemKind::TyAlias(_) => false,
+ hir::ImplItemKind::Type(_) => false,
  }
  });
 
@@ -1596,7 +1596,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
  {
  intravisit::walk_impl_item(self, impl_item)
  }
- hir::ImplItemKind::TyAlias(..) => {
+ hir::ImplItemKind::Type(..) => {
  intravisit::walk_impl_item(self, impl_item)
  }
  _ => {}
@@ -1622,7 +1622,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
  // Those in 3. are warned with this call.
  for impl_item_ref in impl_.items {
  let impl_item = self.tcx.hir().impl_item(impl_item_ref.id);
- if let hir::ImplItemKind::TyAlias(ty) = impl_item.kind {
+ if let hir::ImplItemKind::Type(ty) = impl_item.kind {
  self.visit_ty(ty);
  }
  }

compiler/rustc_resolve/src/late/lifetimes.rs

@@ -898,7 +898,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> {
  Fn(..) => self.visit_early_late(impl_item.hir_id(), &impl_item.generics, |this| {
  intravisit::walk_impl_item(this, impl_item)
  }),
- TyAlias(ref ty) => {
+ Type(ref ty) => {
  let generics = &impl_item.generics;
  let lifetimes: FxIndexMap<LocalDefId, Region> = generics
  .params

compiler/rustc_save_analysis/src/dump_visitor.rs

@@ -1069,7 +1069,7 @@ impl<'tcx> DumpVisitor<'tcx> {
  impl_item.span,
  );
  }
- hir::ImplItemKind::TyAlias(ref ty) => {
+ hir::ImplItemKind::Type(ref ty) => {
  // FIXME: uses of the assoc type should ideally point to this
  // 'def' and the name here should be a ref to the def in the
  // trait.

compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs

@@ -1659,7 +1659,7 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  ..
  })
  | hir::Node::ImplItem(hir::ImplItem {
- kind: hir::ImplItemKind::TyAlias(ty),
+ kind: hir::ImplItemKind::Type(ty),
  ..
  }),
  ) => Some((ty.span, format!("type mismatch resolving `{}`", predicate))),

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -224,7 +224,7 @@ fn extend_cause_with_original_assoc_item_obligation<'tcx>(
  };
  let fix_span =
  |impl_item_ref: &hir::ImplItemRef| match tcx.hir().impl_item(impl_item_ref.id).kind {
- hir::ImplItemKind::Const(ty, _) | hir::ImplItemKind::TyAlias(ty) => ty.span,
+ hir::ImplItemKind::Const(ty, _) | hir::ImplItemKind::Type(ty) => ty.span,
  _ => impl_item_ref.span,
  };
 

compiler/rustc_ty_utils/src/ty.rs

@@ -161,7 +161,7 @@ fn param_env(tcx: TyCtxt<'_>, def_id: DefId) -> ty::ParamEnv<'_> {
  }) => hir::Constness::Const,
 
  hir::Node::ImplItem(hir::ImplItem {
- kind: hir::ImplItemKind::TyAlias(..) | hir::ImplItemKind::Fn(..),
+ kind: hir::ImplItemKind::Type(..) | hir::ImplItemKind::Fn(..),
  ..
  }) => {
  let parent_hir_id = tcx.hir().get_parent_node(hir_id);

library/core/src/alloc/layout.rs

@@ -64,6 +64,7 @@ impl Layout {
  #[stable(feature = "alloc_layout", since = "1.28.0")]
  #[rustc_const_stable(feature = "const_alloc_layout_size_align", since = "1.50.0")]
  #[inline]
+ #[rustc_allow_const_fn_unstable(ptr_alignment_type)]
  pub const fn from_size_align(size: usize, align: usize) -> Result<Self, LayoutError> {
  if !align.is_power_of_two() {
  return Err(LayoutError);
@@ -113,6 +114,7 @@ impl Layout {
  #[rustc_const_stable(feature = "const_alloc_layout_unchecked", since = "1.36.0")]
  #[must_use]
  #[inline]
+ #[rustc_allow_const_fn_unstable(ptr_alignment_type)]
  pub const unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self {
  // SAFETY: the caller is required to uphold the preconditions.
  unsafe { Layout { size, align: ValidAlign::new_unchecked(align) } }
@@ -133,6 +135,7 @@ impl Layout {
  #[must_use = "this returns the minimum alignment, \
  without modifying the layout"]
  #[inline]
+ #[rustc_allow_const_fn_unstable(ptr_alignment_type)]
  pub const fn align(&self) -> usize {
  self.align.as_usize()
  }

library/core/src/lib.rs

@@ -152,6 +152,7 @@
 #![feature(core_panic)]
 #![feature(duration_consts_float)]
 #![feature(maybe_uninit_uninit_array)]
+#![feature(ptr_alignment_type)]
 #![feature(ptr_metadata)]
 #![feature(slice_ptr_get)]
 #![feature(slice_split_at_unchecked)]

library/core/src/mem/mod.rs

@@ -21,11 +21,10 @@ mod maybe_uninit;
 #[stable(feature = "maybe_uninit", since = "1.36.0")]
 pub use maybe_uninit::MaybeUninit;
 
-mod valid_align;
-// For now this type is left crate-local. It could potentially make sense to expose
-// it publicly, as it would be a nice parameter type for methods which need to take
-// alignment as a parameter, such as `Layout::padding_needed_for`.
-pub(crate) use valid_align::ValidAlign;
+// FIXME: This is left here for now to avoid complications around pending reverts.
+// Once <https:/rust-lang/rust/issues/101899> is fully resolved,
+// this should be removed and the references in `alloc::Layout` updated.
+pub(crate) use ptr::Alignment as ValidAlign;
 
 mod transmutability;
 #[unstable(feature = "transmutability", issue = "99571")]