Rollup of 7 pull requests

compiler/rustc_borrowck/src/diagnostics/region_name.rs

@@ -516,7 +516,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
  // be the same as those of the ADT.
  // FIXME: We should be able to do something similar to
  // match_adt_and_segment in this case.
- Res::Def(DefKind::TyAlias, _) => (),
+ Res::Def(DefKind::TyAlias { .. }, _) => (),
  _ => {
  if let Some(last_segment) = path.segments.last() {
  if let Some(highlight) = self.match_adt_and_segment(

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -233,15 +233,6 @@ fn exported_symbols_provider_local(
  ));
  }
 
- symbols.push((
- ExportedSymbol::NoDefId(SymbolName::new(tcx, OomStrategy::SYMBOL)),
- SymbolExportInfo {
- level: SymbolExportLevel::Rust,
- kind: SymbolExportKind::Text,
- used: false,
- },
- ));
-
  let exported_symbol =
  ExportedSymbol::NoDefId(SymbolName::new(tcx, NO_ALLOC_SHIM_IS_UNSTABLE));
  symbols.push((

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -29,7 +29,6 @@ const ARM_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
  ("aclass", Some(sym::arm_target_feature)),
  ("aes", Some(sym::arm_target_feature)),
  ("crc", Some(sym::arm_target_feature)),
- ("crypto", Some(sym::arm_target_feature)),
  ("d32", Some(sym::arm_target_feature)),
  ("dotprod", Some(sym::arm_target_feature)),
  ("dsp", Some(sym::arm_target_feature)),

compiler/rustc_hir/src/def.rs

@@ -61,7 +61,9 @@ pub enum DefKind {
  Variant,
  Trait,
  /// Type alias: `type Foo = Bar;`
- TyAlias,
+ TyAlias {
+ lazy: bool,
+ },
  /// Type from an `extern` block.
  ForeignTy,
  /// Trait alias: `trait IntIterator = Iterator<Item = i32>;`
@@ -141,7 +143,7 @@ impl DefKind {
  DefKind::Ctor(CtorOf::Struct, CtorKind::Fn) => "tuple struct",
  DefKind::Ctor(CtorOf::Struct, CtorKind::Const) => "unit struct",
  DefKind::OpaqueTy => "opaque type",
- DefKind::TyAlias => "type alias",
+ DefKind::TyAlias { .. } => "type alias",
  DefKind::TraitAlias => "trait alias",
  DefKind::AssocTy => "associated type",
  DefKind::Union => "union",
@@ -197,7 +199,7 @@ impl DefKind {
  | DefKind::Variant
  | DefKind::Trait
  | DefKind::OpaqueTy
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::TraitAlias
  | DefKind::AssocTy
@@ -248,7 +250,7 @@ impl DefKind {
  | DefKind::Enum
  | DefKind::Variant
  | DefKind::Trait
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::TraitAlias
  | DefKind::AssocTy

compiler/rustc_hir/src/target.rs

@@ -101,7 +101,7 @@ impl Target {
  DefKind::Mod => Target::Mod,
  DefKind::ForeignMod => Target::ForeignMod,
  DefKind::GlobalAsm => Target::GlobalAsm,
- DefKind::TyAlias => Target::TyAlias,
+ DefKind::TyAlias { .. } => Target::TyAlias,
  DefKind::OpaqueTy => Target::OpaqueTy,
  DefKind::Enum => Target::Enum,
  DefKind::Struct => Target::Struct,

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -907,19 +907,21 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  did: DefId,
  item_segment: &hir::PathSegment<'_>,
  ) -> Ty<'tcx> {
+ let tcx = self.tcx();
  let args = self.ast_path_args_for_ty(span, did, item_segment);
- let ty = self.tcx().at(span).type_of(did);
+ let ty = tcx.at(span).type_of(did);
 
- if matches!(self.tcx().def_kind(did), DefKind::TyAlias)
- && (ty.skip_binder().has_opaque_types() || self.tcx().features().lazy_type_alias)
+ if let DefKind::TyAlias { lazy } = tcx.def_kind(did)
+ && (lazy || ty.skip_binder().has_opaque_types())
  {
  // Type aliases referring to types that contain opaque types (but aren't just directly
- // referencing a single opaque type) get encoded as a type alias that normalization will
+ // referencing a single opaque type) as well as those defined in crates that have the
+ // feature `lazy_type_alias` enabled get encoded as a type alias that normalization will
  // then actually instantiate the where bounds of.
- let alias_ty = self.tcx().mk_alias_ty(did, args);
- Ty::new_alias(self.tcx(), ty::Weak, alias_ty)
+ let alias_ty = tcx.mk_alias_ty(did, args);
+ Ty::new_alias(tcx, ty::Weak, alias_ty)
  } else {
- ty.instantiate(self.tcx(), args)
+ ty.instantiate(tcx, args)
  }
  }
 
@@ -2158,7 +2160,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  }
  Res::Def(
  DefKind::Enum
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::Struct
  | DefKind::Union
  | DefKind::ForeignTy,

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -74,7 +74,7 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
  // we have some type like `&<Ty as Trait>::Assoc`, since users of
  // autoderef expect this type to have been structurally normalized.
  if self.infcx.next_trait_solver()
- && let ty::Alias(ty::Projection, _) = ty.kind()
+ && let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, _) = ty.kind()
  {
  let (normalized_ty, obligations) = self.structurally_normalize(ty)?;
  self.state.obligations.extend(obligations);

compiler/rustc_hir_analysis/src/check/check.rs

@@ -728,7 +728,7 @@ fn check_item_type(tcx: TyCtxt<'_>, id: hir::ItemId) {
  check_opaque(tcx, id);
  }
  }
- DefKind::TyAlias => {
+ DefKind::TyAlias { .. } => {
  let pty_ty = tcx.type_of(id.owner_id).instantiate_identity();
  let generics = tcx.generics_of(id.owner_id);
  check_type_params_are_used(tcx, &generics, pty_ty);

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -1480,7 +1480,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
  DefKind::Struct
  | DefKind::Union
  | DefKind::Enum
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::Trait,
  def_id,
  ) if depth == 0 => Some(def_id),
@@ -1990,7 +1990,7 @@ fn is_late_bound_map(
 
  hir::TyKind::Path(hir::QPath::Resolved(
  None,
- hir::Path { res: Res::Def(DefKind::TyAlias, alias_def), segments, span },
+ hir::Path { res: Res::Def(DefKind::TyAlias { .. }, alias_def), segments, span },
  )) => {
  // See comments on `ConstrainedCollectorPostAstConv` for why this arm does not just consider
  // args to be unconstrained.

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -78,9 +78,8 @@ pub fn add_constraints_from_crate<'a, 'tcx>(
  }
  }
  DefKind::Fn | DefKind::AssocFn => constraint_cx.build_constraints_for_item(def_id),
- DefKind::TyAlias
- if tcx.features().lazy_type_alias
- || tcx.type_of(def_id).instantiate_identity().has_opaque_types() =>
+ DefKind::TyAlias { lazy }
+ if lazy || tcx.type_of(def_id).instantiate_identity().has_opaque_types() =>
  {
  constraint_cx.build_constraints_for_item(def_id)
  }
@@ -111,8 +110,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
 
  // The type as returned by `type_of` is the underlying type and generally not a weak projection.
  // Therefore we need to check the `DefKind` first.
- if let DefKind::TyAlias = tcx.def_kind(def_id)
- && (tcx.features().lazy_type_alias || ty.has_opaque_types())
+ if let DefKind::TyAlias { lazy } = tcx.def_kind(def_id)
+ && (lazy || ty.has_opaque_types())
  {
  self.add_constraints_from_ty(current_item, ty, self.covariant);
  return;

compiler/rustc_hir_analysis/src/variance/mod.rs

@@ -56,9 +56,8 @@ fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Variance] {
  let crate_map = tcx.crate_variances(());
  return crate_map.variances.get(&item_def_id.to_def_id()).copied().unwrap_or(&[]);
  }
- DefKind::TyAlias
- if tcx.features().lazy_type_alias
- || tcx.type_of(item_def_id).instantiate_identity().has_opaque_types() =>
+ DefKind::TyAlias { lazy }
+ if lazy || tcx.type_of(item_def_id).instantiate_identity().has_opaque_types() =>
  {
  // These are inferred.
  let crate_map = tcx.crate_variances(());

compiler/rustc_hir_analysis/src/variance/terms.rs

@@ -97,9 +97,8 @@ pub fn determine_parameters_to_be_inferred<'a, 'tcx>(
  }
  }
  DefKind::Fn | DefKind::AssocFn => terms_cx.add_inferreds_for_item(def_id),
- DefKind::TyAlias
- if tcx.features().lazy_type_alias
- || tcx.type_of(def_id).instantiate_identity().has_opaque_types() =>
+ DefKind::TyAlias { lazy }
+ if lazy || tcx.type_of(def_id).instantiate_identity().has_opaque_types() =>
  {
  terms_cx.add_inferreds_for_item(def_id)
  }

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1012,6 +1012,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  cause: Option<ObligationCause<'tcx>>,
  ) -> RelateResult<'tcx, Ty<'tcx>> {
  let source = self.try_structurally_resolve_type(expr.span, expr_ty);
+ let target = self.try_structurally_resolve_type(
+ cause.as_ref().map_or(expr.span, |cause| cause.span),
+ target,
+ );
  debug!("coercion::try({:?}: {:?} -> {:?})", expr, source, target);
 
  let cause =
@@ -1097,8 +1101,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  where
  E: AsCoercionSite,
  {
- let prev_ty = self.resolve_vars_with_obligations(prev_ty);
- let new_ty = self.resolve_vars_with_obligations(new_ty);
+ let prev_ty = self.try_structurally_resolve_type(cause.span, prev_ty);
+ let new_ty = self.try_structurally_resolve_type(new.span, new_ty);
  debug!(
  "coercion::try_find_coercion_lub({:?}, {:?}, exprs={:?} exprs)",
  prev_ty,

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1474,7 +1474,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let ty = self.resolve_vars_with_obligations(ty);
 
  if self.next_trait_solver()
- && let ty::Alias(ty::Projection, _) = ty.kind()
+ && let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, _) = ty.kind()
  {
  match self
  .at(&self.misc(sp), self.param_env)

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -1359,7 +1359,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
  _ => bug!("unexpected type: {:?}", ty.normalized),
  },
- Res::Def(DefKind::Struct | DefKind::Union | DefKind::TyAlias | DefKind::AssocTy, _)
+ Res::Def(
+ DefKind::Struct | DefKind::Union | DefKind::TyAlias { .. } | DefKind::AssocTy,
+ _,
+ )
  | Res::SelfTyParam { .. }
  | Res::SelfTyAlias { .. } => match ty.normalized.ty_adt_def() {
  Some(adt) if !adt.is_enum() => {

compiler/rustc_hir_typeck/src/mem_categorization.rs

@@ -557,7 +557,10 @@ impl<'a, 'tcx> MemCategorizationContext<'a, 'tcx> {
  Ok(adt_def.variant_index_with_ctor_id(variant_ctor_id))
  }
  Res::Def(DefKind::Ctor(CtorOf::Struct, ..), _)
- | Res::Def(DefKind::Struct | DefKind::Union | DefKind::TyAlias | DefKind::AssocTy, _)
+ | Res::Def(
+ DefKind::Struct | DefKind::Union | DefKind::TyAlias { .. } | DefKind::AssocTy,
+ _,
+ )
  | Res::SelfCtor(..)
  | Res::SelfTyParam { .. }
  | Res::SelfTyAlias { .. } => {

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

@@ -951,7 +951,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
  //
  // See the `need_type_info/issue-103053.rs` test for
  // a example.
- if !matches!(path.res, Res::Def(DefKind::TyAlias, _)) => {
+ if !matches!(path.res, Res::Def(DefKind::TyAlias { .. }, _)) => {
  if let Some(ty) = self.opt_node_type(expr.hir_id)
  && let ty::Adt(_, args) = ty.kind()
  {
@@ -1080,7 +1080,7 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> {
  ) => {
  if tcx.res_generics_def_id(path.res) != Some(def.did()) {
  match path.res {
- Res::Def(DefKind::TyAlias, _) => {
+ Res::Def(DefKind::TyAlias { .. }, _) => {
  // FIXME: Ideally we should support this. For that
  // we have to map back from the self type to the
  // type alias though. That's difficult.

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -819,7 +819,7 @@ fn should_encode_span(def_kind: DefKind) -> bool {
  | DefKind::Enum
  | DefKind::Variant
  | DefKind::Trait
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::TraitAlias
  | DefKind::AssocTy
@@ -854,7 +854,7 @@ fn should_encode_attrs(def_kind: DefKind) -> bool {
  | DefKind::Enum
  | DefKind::Variant
  | DefKind::Trait
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::TraitAlias
  | DefKind::AssocTy
@@ -895,7 +895,7 @@ fn should_encode_expn_that_defined(def_kind: DefKind) -> bool {
  | DefKind::Variant
  | DefKind::Trait
  | DefKind::Impl { .. } => true,
- DefKind::TyAlias
+ DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::TraitAlias
  | DefKind::AssocTy
@@ -930,7 +930,7 @@ fn should_encode_visibility(def_kind: DefKind) -> bool {
  | DefKind::Enum
  | DefKind::Variant
  | DefKind::Trait
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::TraitAlias
  | DefKind::AssocTy
@@ -974,7 +974,7 @@ fn should_encode_stability(def_kind: DefKind) -> bool {
  | DefKind::Const
  | DefKind::Fn
  | DefKind::ForeignMod
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::OpaqueTy
  | DefKind::Enum
  | DefKind::Union
@@ -1067,9 +1067,8 @@ fn should_encode_variances<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, def_kind: Def
  | DefKind::Closure
  | DefKind::Generator
  | DefKind::ExternCrate => false,
- DefKind::TyAlias => {
- tcx.features().lazy_type_alias
- || tcx.type_of(def_id).instantiate_identity().has_opaque_types()
+ DefKind::TyAlias { lazy } => {
+ lazy || tcx.type_of(def_id).instantiate_identity().has_opaque_types()
  }
  }
 }
@@ -1081,7 +1080,7 @@ fn should_encode_generics(def_kind: DefKind) -> bool {
  | DefKind::Enum
  | DefKind::Variant
  | DefKind::Trait
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::TraitAlias
  | DefKind::AssocTy
@@ -1121,7 +1120,7 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
  | DefKind::Fn
  | DefKind::Const
  | DefKind::Static(..)
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::ForeignTy
  | DefKind::Impl { .. }
  | DefKind::AssocFn
@@ -1181,7 +1180,7 @@ fn should_encode_fn_sig(def_kind: DefKind) -> bool {
  | DefKind::Const
  | DefKind::Static(..)
  | DefKind::Ctor(..)
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::OpaqueTy
  | DefKind::ForeignTy
  | DefKind::Impl { .. }
@@ -1222,7 +1221,7 @@ fn should_encode_constness(def_kind: DefKind) -> bool {
  | DefKind::AssocConst
  | DefKind::AnonConst
  | DefKind::Static(..)
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::OpaqueTy
  | DefKind::Impl { of_trait: false }
  | DefKind::ForeignTy
@@ -1255,7 +1254,7 @@ fn should_encode_const(def_kind: DefKind) -> bool {
  | DefKind::Field
  | DefKind::Fn
  | DefKind::Static(..)
- | DefKind::TyAlias
+ | DefKind::TyAlias { .. }
  | DefKind::OpaqueTy
  | DefKind::ForeignTy
  | DefKind::Impl { .. }

compiler/rustc_metadata/src/rmeta/table.rs

@@ -126,7 +126,8 @@ fixed_size_enum! {
  ( Enum )
  ( Variant )
  ( Trait )
- ( TyAlias )
+ ( TyAlias { lazy: false } )
+ ( TyAlias { lazy: true } )
  ( ForeignTy )
  ( TraitAlias )
  ( AssocTy )

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

@@ -196,7 +196,9 @@ impl<'hir> Map<'hir> {
  ItemKind::Macro(_, macro_kind) => DefKind::Macro(macro_kind),
  ItemKind::Mod(..) => DefKind::Mod,
  ItemKind::OpaqueTy(..) => DefKind::OpaqueTy,
- ItemKind::TyAlias(..) => DefKind::TyAlias,
+ ItemKind::TyAlias(..) => {
+ DefKind::TyAlias { lazy: self.tcx.features().lazy_type_alias }
+ }
  ItemKind::Enum(..) => DefKind::Enum,
  ItemKind::Struct(..) => DefKind::Struct,
  ItemKind::Union(..) => DefKind::Union,