Auto merge of rust-lang#126671 - fmease:rollup-dmet4fi, r=fmease

Rollup of 7 pull requests

Successful merges:

 - rust-lang#123782 (Test that opaque types can't have themselves as a hidden type with incompatible lifetimes)
 - rust-lang#124580 (Suggest removing unused tuple fields if they are the last fields)
 - rust-lang#125787 (Migrate `bin-emit-no-symbols` `run-make` test to `rmake`)
 - rust-lang#126553 (match lowering: expand or-candidates mixed with candidates above)
 - rust-lang#126594 (Make async drop code more consistent with regular drop code)
 - rust-lang#126654 (Make pretty printing for `f16` and `f128` consistent)
 - rust-lang#126656 (rustc_type_ir: Omit some struct fields from Debug output)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -371,7 +371,7 @@ fn exported_symbols_provider_local(
  }) => {
  // A little sanity-check
  debug_assert_eq!(
- args.non_erasable_generics(tcx, def_id).skip(1).next(),
+ args.non_erasable_generics(tcx, def_id).next(),
  Some(GenericArgKind::Type(ty))
  );
  symbols.push((
@@ -422,10 +422,7 @@ fn upstream_monomorphizations_provider(
  }
  ExportedSymbol::AsyncDropGlueCtorShim(ty) => {
  if let Some(async_drop_in_place_fn_def_id) = async_drop_in_place_fn_def_id {
- (
- async_drop_in_place_fn_def_id,
- tcx.mk_args(&[tcx.lifetimes.re_erased.into(), ty.into()]),
- )
+ (async_drop_in_place_fn_def_id, tcx.mk_args(&[ty.into()]))
  } else {
  // `drop_in_place` in place does not exist, don't try
  // to use it.
@@ -473,11 +470,16 @@ fn upstream_drop_glue_for_provider<'tcx>(
  tcx: TyCtxt<'tcx>,
  args: GenericArgsRef<'tcx>,
 ) -> Option<CrateNum> {
- if let Some(def_id) = tcx.lang_items().drop_in_place_fn() {
- tcx.upstream_monomorphizations_for(def_id).and_then(|monos| monos.get(&args).cloned())
- } else {
- None
- }
+ let def_id = tcx.lang_items().drop_in_place_fn()?;
+ tcx.upstream_monomorphizations_for(def_id)?.get(&args).cloned()
+}
+
+fn upstream_async_drop_glue_for_provider<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ args: GenericArgsRef<'tcx>,
+) -> Option<CrateNum> {
+ let def_id = tcx.lang_items().async_drop_in_place_fn()?;
+ tcx.upstream_monomorphizations_for(def_id)?.get(&args).cloned()
 }
 
 fn is_unreachable_local_definition_provider(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
@@ -491,6 +493,7 @@ pub fn provide(providers: &mut Providers) {
  providers.upstream_monomorphizations = upstream_monomorphizations_provider;
  providers.is_unreachable_local_definition = is_unreachable_local_definition_provider;
  providers.upstream_drop_glue_for = upstream_drop_glue_for_provider;
+ providers.upstream_async_drop_glue_for = upstream_async_drop_glue_for_provider;
  providers.wasm_import_module_map = wasm_import_module_map;
  providers.extern_queries.is_reachable_non_generic = is_reachable_non_generic_provider_extern;
  providers.extern_queries.upstream_monomorphizations_for =

compiler/rustc_middle/src/query/mod.rs

@@ -1554,12 +1554,13 @@ rustc_queries! {
  }
  }
 
- /// The entire set of monomorphizations the local crate can safely link
- /// to because they are exported from upstream crates. Do not depend on
- /// this directly, as its value changes anytime a monomorphization gets
- /// added or removed in any upstream crate. Instead use the narrower
- /// `upstream_monomorphizations_for`, `upstream_drop_glue_for`, or, even
- /// better, `Instance::upstream_monomorphization()`.
+ /// The entire set of monomorphizations the local crate can safely
+ /// link to because they are exported from upstream crates. Do
+ /// not depend on this directly, as its value changes anytime
+ /// a monomorphization gets added or removed in any upstream
+ /// crate. Instead use the narrower `upstream_monomorphizations_for`,
+ /// `upstream_drop_glue_for`, `upstream_async_drop_glue_for`, or,
+ /// even better, `Instance::upstream_monomorphization()`.
  query upstream_monomorphizations(_: ()) -> &'tcx DefIdMap<UnordMap<GenericArgsRef<'tcx>, CrateNum>> {
  arena_cache
  desc { "collecting available upstream monomorphizations" }
@@ -1601,6 +1602,26 @@ rustc_queries! {
  desc { "available upstream drop-glue for `{:?}`", args }
  }
 
+ /// Returns the upstream crate that exports async-drop-glue for
+ /// the given type (`args` is expected to be a single-item list
+ /// containing the type one wants async-drop-glue for).
+ ///
+ /// This is a subset of `upstream_monomorphizations_for` in order
+ /// to increase dep-tracking granularity. Otherwise adding or
+ /// removing any type with async-drop-glue in any upstream crate
+ /// would invalidate all functions calling async-drop-glue of an
+ /// upstream type.
+ ///
+ /// You likely want to call `Instance::upstream_monomorphization()`
+ /// instead of invoking this query directly.
+ ///
+ /// NOTE: This query could easily be extended to also support other
+ /// common functions that have are large set of monomorphizations
+ /// (like `Clone::clone` for example).
+ query upstream_async_drop_glue_for(args: GenericArgsRef<'tcx>) -> Option<CrateNum> {
+ desc { "available upstream async-drop-glue for `{:?}`", args }
+ }
+
  /// Returns a list of all `extern` blocks of a crate.
  query foreign_modules(_: CrateNum) -> &'tcx FxIndexMap<DefId, ForeignModule> {
  arena_cache

compiler/rustc_middle/src/ty/instance.rs

@@ -219,8 +219,9 @@ impl<'tcx> Instance<'tcx> {
  InstanceKind::Item(def) => tcx
  .upstream_monomorphizations_for(def)
  .and_then(|monos| monos.get(&self.args).cloned()),
- InstanceKind::DropGlue(_, Some(_)) | InstanceKind::AsyncDropGlueCtorShim(_, _) => {
- tcx.upstream_drop_glue_for(self.args)
+ InstanceKind::DropGlue(_, Some(_)) => tcx.upstream_drop_glue_for(self.args),
+ InstanceKind::AsyncDropGlueCtorShim(_, Some(_)) => {
+ tcx.upstream_async_drop_glue_for(self.args)
  }
  _ => None,
  }
@@ -256,7 +257,7 @@ impl<'tcx> InstanceKind<'tcx> {
  match self {
  ty::InstanceKind::Item(def) => Some(def),
  ty::InstanceKind::DropGlue(def_id, Some(_))
- | InstanceKind::AsyncDropGlueCtorShim(def_id, _)
+ | InstanceKind::AsyncDropGlueCtorShim(def_id, Some(_))
  | InstanceKind::ThreadLocalShim(def_id) => Some(def_id),
  InstanceKind::VTableShim(..)
  | InstanceKind::ReifyShim(..)
@@ -267,6 +268,7 @@ impl<'tcx> InstanceKind<'tcx> {
  | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
  | ty::InstanceKind::CoroutineKindShim { .. }
  | InstanceKind::DropGlue(..)
+ | InstanceKind::AsyncDropGlueCtorShim(..)
  | InstanceKind::CloneShim(..)
  | InstanceKind::FnPtrAddrShim(..) => None,
  }
@@ -312,7 +314,9 @@ impl<'tcx> InstanceKind<'tcx> {
  if self.requires_inline(tcx) {
  return true;
  }
- if let ty::InstanceKind::DropGlue(.., Some(ty)) = *self {
+ if let ty::InstanceKind::DropGlue(.., Some(ty))
+ | ty::InstanceKind::AsyncDropGlueCtorShim(.., Some(ty)) = *self
+ {
  // Drop glue generally wants to be instantiated at every codegen
  // unit, but without an #[inline] hint. We should make this
  // available to normal end-users.
@@ -327,9 +331,14 @@ impl<'tcx> InstanceKind<'tcx> {
  // drops of `Option::None` before LTO. We also respect the intent of
  // `#[inline]` on `Drop::drop` implementations.
  return ty.ty_adt_def().map_or(true, |adt_def| {
- adt_def
- .destructor(tcx)
- .map_or_else(|| adt_def.is_enum(), |dtor| tcx.cross_crate_inlinable(dtor.did))
+ match *self {
+ ty::InstanceKind::DropGlue(..) => adt_def.destructor(tcx).map(|dtor| dtor.did),
+ ty::InstanceKind::AsyncDropGlueCtorShim(..) => {
+ adt_def.async_destructor(tcx).map(|dtor| dtor.ctor)
+ }
+ _ => unreachable!(),
+ }
+ .map_or_else(|| adt_def.is_enum(), |did| tcx.cross_crate_inlinable(did))
  });
  }
  if let ty::InstanceKind::ThreadLocalShim(..) = *self {

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

@@ -7,7 +7,7 @@ use crate::ty::{
  ConstInt, Expr, ParamConst, ScalarInt, Term, TermKind, TypeFoldable, TypeSuperFoldable,
  TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
 };
-use rustc_apfloat::ieee::{Double, Single};
+use rustc_apfloat::ieee::{Double, Half, Quad, Single};
 use rustc_apfloat::Float;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_data_structures::unord::UnordMap;
@@ -1710,6 +1710,10 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
  ty::Bool if int == ScalarInt::FALSE => p!("false"),
  ty::Bool if int == ScalarInt::TRUE => p!("true"),
  // Float
+ ty::Float(ty::FloatTy::F16) => {
+ let val = Half::try_from(int).unwrap();
+ p!(write("{}{}f16", val, if val.is_finite() { "" } else { "_" }))
+ }
  ty::Float(ty::FloatTy::F32) => {
  let val = Single::try_from(int).unwrap();
  p!(write("{}{}f32", val, if val.is_finite() { "" } else { "_" }))
@@ -1718,6 +1722,10 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
  let val = Double::try_from(int).unwrap();
  p!(write("{}{}f64", val, if val.is_finite() { "" } else { "_" }))
  }
+ ty::Float(ty::FloatTy::F128) => {
+ let val = Quad::try_from(int).unwrap();
+ p!(write("{}{}f128", val, if val.is_finite() { "" } else { "_" }))
+ }
  // Int
  ty::Uint(_) | ty::Int(_) => {
  let int =