Auto merge of #148202 - Zalathar:rollup-2eriuc3, r=Zalathar

Rollup of 14 pull requests Successful merges: - #144936 (CFI: Fix types that implement Fn, FnMut, or FnOnce) - #147185 (repr(transparent): do not consider repr(C) types to be 1-ZST) - #147840 (Rework unsizing coercions in the new solver) - #147915 (Update target maintainers android.md) - #148013 (1.91.0 release notes) - #148044 (compiletest: show output in debug logging) - #148057 (tests/ui/sanitizer/hwaddress.rs: Run on aarch64 and remove cgu hack) - #148139 (Add `coverage` scope for controlling paths in code coverage) - #148154 (Add a mailmap entry) - #148158 (ci: loongarch64: use medium code model to avoid relocation overflows) - #148166 (Re-enable macro-stepping test for AArch64) - #148172 (rustc-dev-guide subtree update) - #148175 (Fix typos: duplicate words in comments) - #148186 (rustdoc-search: add an integration test for CCI) Failed merges: - #147935 (Add LLVM realtime sanitizer) r? `@ghost` `@rustbot` modify labels: rollup

Author: bors

.mailmap

@@ -680,6 +680,7 @@ Valerii Lashmanov <vflashm@gmail.com>
 Vitali Haravy <HumaneProgrammer@gmail.com> Vitali Haravy <humaneprogrammer@gmail.com>
 Vitaly Shukela <vi0oss@gmail.com>
 Waffle Lapkin <waffle.lapkin@gmail.com>
+Waffle Lapkin <waffle.lapkin@gmail.com> <Waffle Lapkin>
 Waffle Lapkin <waffle.lapkin@gmail.com> <waffle.lapkin@tasking.com>
 Weihang Lo <me@weihanglo.tw>
 Weihang Lo <me@weihanglo.tw> <weihanglo@users.noreply.github.com>

RELEASES.md

@@ -298,7 +298,7 @@ impl Printer {
  }
  }
 
- // This is is where `BoxMarker`s are produced.
+ // This is where `BoxMarker`s are produced.
  fn scan_begin(&mut self, token: BeginToken) -> BoxMarker {
  if self.scan_stack.is_empty() {
  self.left_total = 1;
@@ -310,7 +310,7 @@ impl Printer {
  BoxMarker
  }
 
- // This is is where `BoxMarker`s are consumed.
+ // This is where `BoxMarker`s are consumed.
  fn scan_end(&mut self, b: BoxMarker) {
  if self.scan_stack.is_empty() {
  self.print_end();

compiler/rustc_ast_pretty/src/pp.rs

@@ -128,7 +128,7 @@ impl GlobalFileTable {
  for file in all_files {
  raw_file_table.entry(file.stable_id).or_insert_with(|| {
  file.name
- .for_scope(tcx.sess, RemapPathScopeComponents::MACRO)
+ .for_scope(tcx.sess, RemapPathScopeComponents::COVERAGE)
  .to_string_lossy()
  .into_owned()
  });
@@ -147,7 +147,7 @@ impl GlobalFileTable {
  .sess
  .opts
  .working_dir
- .for_scope(tcx.sess, RemapPathScopeComponents::MACRO)
+ .for_scope(tcx.sess, RemapPathScopeComponents::COVERAGE)
  .to_string_lossy();
  table.push(base_dir.as_ref());
 

compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs

@@ -121,7 +121,7 @@ impl EnteredTraceSpan for tracing::span::EnteredSpan {
 /// ### `tracing_separate_thread` parameter
 ///
 /// This macro was introduced to obtain better traces of Miri without impacting release performance.
-/// Miri saves traces using the the `tracing_chrome` `tracing::Layer` so that they can be visualized
+/// Miri saves traces using the `tracing_chrome` `tracing::Layer` so that they can be visualized
 /// in <https://ui.perfetto.dev>. To instruct `tracing_chrome` to put some spans on a separate trace
 /// thread/line than other spans when viewed in <https://ui.perfetto.dev>, you can pass
 /// `tracing_separate_thread = tracing::field::Empty` to the tracing macros. This is useful to

compiler/rustc_const_eval/src/interpret/util.rs

@@ -12,9 +12,7 @@ use rustc_hir::def::{CtorKind, DefKind};
 use rustc_hir::{LangItem, Node, attrs, find_attr, intravisit};
 use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
 use rustc_infer::traits::{Obligation, ObligationCauseCode, WellFormedLoc};
-use rustc_lint_defs::builtin::{
- REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS, UNSUPPORTED_CALLING_CONVENTIONS,
-};
+use rustc_lint_defs::builtin::{REPR_TRANSPARENT_NON_ZST_FIELDS, UNSUPPORTED_CALLING_CONVENTIONS};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::middle::stability::EvalResult;
@@ -1509,31 +1507,46 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
  }
 
  let typing_env = ty::TypingEnv::non_body_analysis(tcx, adt.did());
- // For each field, figure out if it's known to have "trivial" layout (i.e., is a 1-ZST), with
- // "known" respecting #[non_exhaustive] attributes.
+ // For each field, figure out if it has "trivial" layout (i.e., is a 1-ZST).
+ // Even some 1-ZST fields are not allowed though, if they have `non_exhaustive` or private
+ // fields or `repr(C)`. We call those fields "unsuited".
+ struct FieldInfo<'tcx> {
+ span: Span,
+ trivial: bool,
+ unsuited: Option<UnsuitedInfo<'tcx>>,
+ }
+ struct UnsuitedInfo<'tcx> {
+ /// The source of the problem, a type that is found somewhere within the field type.
+ ty: Ty<'tcx>,
+ reason: UnsuitedReason,
+ }
+ enum UnsuitedReason {
+ NonExhaustive,
+ PrivateField,
+ ReprC,
+ }
+
  let field_infos = adt.all_fields().map(|field| {
  let ty = field.ty(tcx, GenericArgs::identity_for_item(tcx, field.did));
  let layout = tcx.layout_of(typing_env.as_query_input(ty));
  // We are currently checking the type this field came from, so it must be local
  let span = tcx.hir_span_if_local(field.did).unwrap();
  let trivial = layout.is_ok_and(|layout| layout.is_1zst());
  if !trivial {
- return (span, trivial, None);
+ // No need to even compute `unsuited`.
+ return FieldInfo { span, trivial, unsuited: None };
  }
- // Even some 1-ZST fields are not allowed though, if they have `non_exhaustive`.
 
- fn check_non_exhaustive<'tcx>(
+ fn check_unsuited<'tcx>(
  tcx: TyCtxt<'tcx>,
  typing_env: ty::TypingEnv<'tcx>,
- t: Ty<'tcx>,
- ) -> ControlFlow<(&'static str, DefId, GenericArgsRef<'tcx>, bool)> {
+ ty: Ty<'tcx>,
+ ) -> ControlFlow<UnsuitedInfo<'tcx>> {
  // We can encounter projections during traversal, so ensure the type is normalized.
- let t = tcx.try_normalize_erasing_regions(typing_env, t).unwrap_or(t);
- match t.kind() {
- ty::Tuple(list) => {
- list.iter().try_for_each(|t| check_non_exhaustive(tcx, typing_env, t))
- }
- ty::Array(ty, _) => check_non_exhaustive(tcx, typing_env, *ty),
+ let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+ match ty.kind() {
+ ty::Tuple(list) => list.iter().try_for_each(|t| check_unsuited(tcx, typing_env, t)),
+ ty::Array(ty, _) => check_unsuited(tcx, typing_env, *ty),
  ty::Adt(def, args) => {
  if !def.did().is_local()
  && !find_attr!(
@@ -1548,28 +1561,36 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
  .any(ty::VariantDef::is_field_list_non_exhaustive);
  let has_priv = def.all_fields().any(|f| !f.vis.is_public());
  if non_exhaustive || has_priv {
- return ControlFlow::Break((
- def.descr(),
- def.did(),
- args,
- non_exhaustive,
- ));
+ return ControlFlow::Break(UnsuitedInfo {
+ ty,
+ reason: if non_exhaustive {
+ UnsuitedReason::NonExhaustive
+ } else {
+ UnsuitedReason::PrivateField
+ },
+ });
  }
  }
+ if def.repr().c() {
+ return ControlFlow::Break(UnsuitedInfo {
+ ty,
+ reason: UnsuitedReason::ReprC,
+ });
+ }
  def.all_fields()
  .map(|field| field.ty(tcx, args))
- .try_for_each(|t| check_non_exhaustive(tcx, typing_env, t))
+ .try_for_each(|t| check_unsuited(tcx, typing_env, t))
  }
  _ => ControlFlow::Continue(()),
  }
  }
 
- (span, trivial, check_non_exhaustive(tcx, typing_env, ty).break_value())
+ FieldInfo { span, trivial, unsuited: check_unsuited(tcx, typing_env, ty).break_value() }
  });
 
  let non_trivial_fields = field_infos
  .clone()
- .filter_map(|(span, trivial, _non_exhaustive)| if !trivial { Some(span) } else { None });
+ .filter_map(|field| if !field.trivial { Some(field.span) } else { None });
  let non_trivial_count = non_trivial_fields.clone().count();
  if non_trivial_count >= 2 {
  bad_non_zero_sized_fields(
@@ -1581,36 +1602,40 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
  );
  return;
  }
- let mut prev_non_exhaustive_1zst = false;
- for (span, _trivial, non_exhaustive_1zst) in field_infos {
- if let Some((descr, def_id, args, non_exhaustive)) = non_exhaustive_1zst {
+
+ let mut prev_unsuited_1zst = false;
+ for field in field_infos {
+ if let Some(unsuited) = field.unsuited {
+ assert!(field.trivial);
  // If there are any non-trivial fields, then there can be no non-exhaustive 1-zsts.
  // Otherwise, it's only an issue if there's >1 non-exhaustive 1-zst.
- if non_trivial_count > 0 || prev_non_exhaustive_1zst {
+ if non_trivial_count > 0 || prev_unsuited_1zst {
  tcx.node_span_lint(
- REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS,
+ REPR_TRANSPARENT_NON_ZST_FIELDS,
  tcx.local_def_id_to_hir_id(adt.did().expect_local()),
- span,
+ field.span,
  |lint| {
+ let title = match unsuited.reason {
+ UnsuitedReason::NonExhaustive => "external non-exhaustive types",
+ UnsuitedReason::PrivateField => "external types with private fields",
+ UnsuitedReason::ReprC => "`repr(C)` types",
+ };
  lint.primary_message(
- "zero-sized fields in `repr(transparent)` cannot \
- contain external non-exhaustive types",
+ format!("zero-sized fields in `repr(transparent)` cannot contain {title}"),
  );
- let note = if non_exhaustive {
- "is marked with `#[non_exhaustive]`"
- } else {
- "contains private fields"
+ let note = match unsuited.reason {
+ UnsuitedReason::NonExhaustive => "is marked with `#[non_exhaustive]`, so it could become non-zero-sized in the future.",
+  UnsuitedReason::PrivateField => "contains private fields, so it could become non-zero-sized in the future.",
+ UnsuitedReason::ReprC => "is a `#[repr(C)]` type, so it is not guaranteed to be zero-sized on all targets.",
  };
- let field_ty = tcx.def_path_str_with_args(def_id, args);
  lint.note(format!(
- "this {descr} contains `{field_ty}`, which {note}, \
- and makes it not a breaking change to become \
- non-zero-sized in the future."
+ "this field contains `{field_ty}`, which {note}",
+ field_ty = unsuited.ty,
  ));
  },
- )
+ );
  } else {
- prev_non_exhaustive_1zst = true;
+ prev_unsuited_1zst = true;
  }
  }
  }