Auto merge of rust-lang#125448 - matthiaskrgr:rollup-vn6nleh, r=matth…

…iaskrgr

Rollup of 8 pull requests

Successful merges:

 - rust-lang#124297 (Allow coercing functions whose signature differs in opaque types in their defining scope into a shared function pointer type)
 - rust-lang#124516 (Allow monomorphization time const eval failures if the cause is a type layout issue)
 - rust-lang#124976 (rustc: Use `tcx.used_crates(())` more)
 - rust-lang#125210 (Cleanup: Fix up some diagnostics)
 - rust-lang#125409 (Rename `FrameworkOnlyWindows` to `RawDylibOnlyWindows`)
 - rust-lang#125416 (Use correct param-env in `MissingCopyImplementations`)
 - rust-lang#125421 (Rewrite `core-no-oom-handling`, `issue-24445` and `issue-38237` `run-make` tests to new `rmake.rs` format)
 - rust-lang#125438 (Remove unneeded string conversion)

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

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -786,12 +786,12 @@ fn link_natively(
  if matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _))
  && unknown_arg_regex.is_match(&out)
  && out.contains("-no-pie")
- && cmd.get_args().iter().any(|e| e.to_string_lossy() == "-no-pie")
+ && cmd.get_args().iter().any(|e| e == "-no-pie")
  {
  info!("linker output: {:?}", out);
  warn!("Linker does not support -no-pie command line option. Retrying without.");
  for arg in cmd.take_args() {
- if arg.to_string_lossy() != "-no-pie" {
+ if arg != "-no-pie" {
  cmd.arg(arg);
  }
  }
@@ -825,7 +825,7 @@ fn link_natively(
  if matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _))
  && unknown_arg_regex.is_match(&out)
  && (out.contains("-static-pie") || out.contains("--no-dynamic-linker"))
- && cmd.get_args().iter().any(|e| e.to_string_lossy() == "-static-pie")
+ && cmd.get_args().iter().any(|e| e == "-static-pie")
  {
  info!("linker output: {:?}", out);
  warn!(
@@ -864,7 +864,7 @@ fn link_natively(
  assert!(pre_objects_static.is_empty() || !pre_objects_static_pie.is_empty());
  assert!(post_objects_static.is_empty() || !post_objects_static_pie.is_empty());
  for arg in cmd.take_args() {
- if arg.to_string_lossy() == "-static-pie" {
+ if arg == "-static-pie" {
  // Replace the output kind.
  cmd.arg("-static");
  } else if pre_objects_static_pie.contains(&arg) {

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -399,7 +399,7 @@ fn upstream_monomorphizations_provider(
  tcx: TyCtxt<'_>,
  (): (),
 ) -> DefIdMap<UnordMap<GenericArgsRef<'_>, CrateNum>> {
- let cnums = tcx.crates(());
+ let cnums = tcx.used_crates(());
 
  let mut instances: DefIdMap<UnordMap<_, _>> = Default::default();
 

compiler/rustc_codegen_ssa/src/base.rs

@@ -539,7 +539,7 @@ pub fn collect_debugger_visualizers_transitive(
  tcx.debugger_visualizers(LOCAL_CRATE)
  .iter()
  .chain(
- tcx.crates(())
+ tcx.used_crates(())
  .iter()
  .filter(|&cnum| {
  let used_crate_source = tcx.used_crate_source(*cnum);
@@ -849,7 +849,7 @@ impl CrateInfo {
  // `compiler_builtins` are always placed last to ensure that they're linked correctly.
  used_crates.extend(compiler_builtins);
 
- let crates = tcx.crates(());
+ let crates = tcx.used_crates(());
  let n_crates = crates.len();
  let mut info = CrateInfo {
  target_cpu,

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -2,7 +2,7 @@ use std::mem;
 
 use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage, Diagnostic, IntoDiagArg};
 use rustc_hir::CRATE_HIR_ID;
-use rustc_middle::mir::interpret::Provenance;
+use rustc_middle::mir::interpret::{Provenance, ReportedErrorInfo};
 use rustc_middle::mir::AssertKind;
 use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::TyCtxt;
@@ -139,9 +139,10 @@ where
  ErrorHandled::TooGeneric(span)
  }
  err_inval!(AlreadyReported(guar)) => ErrorHandled::Reported(guar, span),
- err_inval!(Layout(LayoutError::ReferencesError(guar))) => {
- ErrorHandled::Reported(guar.into(), span)
- }
+ err_inval!(Layout(LayoutError::ReferencesError(guar))) => ErrorHandled::Reported(
+ ReportedErrorInfo::tainted_by_errors(guar),
+ span,
+ ),
  // Report remaining errors.
  _ => {
  let (our_span, frames) = get_span_and_frames();

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -1181,9 +1181,20 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  ) -> InterpResult<'tcx, OpTy<'tcx, M::Provenance>> {
  M::eval_mir_constant(self, *val, span, layout, |ecx, val, span, layout| {
  let const_val = val.eval(*ecx.tcx, ecx.param_env, span).map_err(|err| {
- if M::ALL_CONSTS_ARE_PRECHECKED && !matches!(err, ErrorHandled::TooGeneric(..)) {
- // Looks like the const is not captued by `required_consts`, that's bad.
- bug!("interpret const eval failure of {val:?} which is not in required_consts");
+ if M::ALL_CONSTS_ARE_PRECHECKED {
+ match err {
+ ErrorHandled::TooGeneric(..) => {},
+ ErrorHandled::Reported(reported, span) => {
+ if reported.is_tainted_by_errors() {
+ // const-eval will return "tainted" errors if e.g. the layout cannot
+ // be computed as the type references non-existing names.
+ // See <https://github.com/rust-lang/rust/issues/124348>.
+ } else {
+ // Looks like the const is not captued by `required_consts`, that's bad.
+ span_bug!(span, "interpret const eval failure of {val:?} which is not in required_consts");
+ }
+ }
+ }
  }
  err.emit_note(*ecx.tcx);
  err

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1159,7 +1159,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let sig = self
  .at(cause, self.param_env)
  .trace(prev_ty, new_ty)
- .lub(DefineOpaqueTypes::No, a_sig, b_sig)
+ .lub(DefineOpaqueTypes::Yes, a_sig, b_sig)
  .map(|ok| self.register_infer_ok_obligations(ok))?;
 
  // Reify both sides and return the reified fn pointer type.

compiler/rustc_infer/messages.ftl

@@ -104,10 +104,10 @@ infer_compare_impl_item_obligation = ...so that the definition in impl matches t
 infer_consider_specifying_length = consider specifying the actual array length
 infer_data_flows = ...but data{$label_var1_exists ->
  [true] {" "}from `{$label_var1}`
- *[false] -> {""}
+ *[false] {""}
 } flows{$label_var2_exists ->
  [true] {" "}into `{$label_var2}`
- *[false] -> {""}
+ *[false] {""}
 } here
 
 infer_data_lifetime_flow = ...but data with one lifetime flows into the other here

compiler/rustc_interface/src/passes.rs

@@ -458,7 +458,7 @@ fn write_out_deps(tcx: TyCtxt<'_>, outputs: &OutputFilenames, out_filenames: &[P
  }
  }
 
- for &cnum in tcx.crates(()) {
+ for &cnum in tcx.crates_including_speculative(()) {
  let source = tcx.used_crate_source(cnum);
  if let Some((path, _)) = &source.dylib {
  files.push(escape_dep_filename(&path.display().to_string()));

compiler/rustc_lint/messages.ftl

@@ -627,7 +627,7 @@ lint_pattern_in_foreign = patterns aren't allowed in foreign function declaratio
  .label = pattern not allowed in foreign function
 
 lint_private_extern_crate_reexport =
- extern crate `{$ident}` is private, and cannot be re-exported (error E0365), consider declaring with `pub`
+ extern crate `{$ident}` is private, and cannot be re-exported, consider declaring with `pub`
 
 lint_proc_macro_back_compat = using an old version of `{$crate_name}`
  .note = older versions of the `{$crate_name}` crate will stop compiling in future versions of Rust; please update to `{$crate_name}` v{$fixed_version}, or switch to one of the `{$crate_name}` alternatives

compiler/rustc_lint/src/builtin.rs

@@ -674,11 +674,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations {
  return;
  }
  }
- let param_env = ty::ParamEnv::empty();
- if ty.is_copy_modulo_regions(cx.tcx, param_env) {
+ if ty.is_copy_modulo_regions(cx.tcx, cx.param_env) {
  return;
  }
- if type_implements_negative_copy_modulo_regions(cx.tcx, ty, param_env) {
+ if type_implements_negative_copy_modulo_regions(cx.tcx, ty, cx.param_env) {
  return;
  }
  if def.is_variant_list_non_exhaustive()
@@ -694,7 +693,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations {
  .tcx
  .infer_ctxt()
  .build()
- .type_implements_trait(iter_trait, [ty], param_env)
+ .type_implements_trait(iter_trait, [ty], cx.param_env)
  .must_apply_modulo_regions()
  {
  return;
@@ -711,7 +710,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations {
 
  if type_allowed_to_implement_copy(
  cx.tcx,
- param_env,
+ cx.param_env,
  ty,
  traits::ObligationCause::misc(item.span, item.owner_id.def_id),
  )

compiler/rustc_lint/src/lints.rs

@@ -2228,7 +2228,7 @@ pub struct MacroUseDeprecated;
 pub struct UnusedMacroUse;
 
 #[derive(LintDiagnostic)]
-#[diag(lint_private_extern_crate_reexport)]
+#[diag(lint_private_extern_crate_reexport, code = E0365)]
 pub struct PrivateExternCrateReexport {
  pub ident: Ident,
 }

compiler/rustc_metadata/messages.ftl

@@ -91,9 +91,6 @@ metadata_found_staticlib =
  found staticlib `{$crate_name}` instead of rlib or dylib{$add_info}
  .help = please recompile that crate using --crate-type lib
 
-metadata_framework_only_windows =
- link kind `raw-dylib` is only supported on Windows targets
-
 metadata_global_alloc_required =
  no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait
 
@@ -233,6 +230,9 @@ metadata_profiler_builtins_needs_core =
 metadata_raw_dylib_no_nul =
  link name must not contain NUL characters if link kind is `raw-dylib`
 
+metadata_raw_dylib_only_windows =
+ link kind `raw-dylib` is only supported on Windows targets
+
 metadata_renaming_no_link =
  renaming of the library `{$lib_name}` was specified, however this crate contains no `#[link(...)]` attributes referencing this library
 

compiler/rustc_metadata/src/dependency_format.rs

@@ -143,7 +143,7 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
  && sess.crt_static(Some(ty))
  && !sess.target.crt_static_allows_dylibs)
  {
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
  if tcx.dep_kind(cnum).macros_only() {
  continue;
  }
@@ -164,7 +164,7 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
  // Sweep all crates for found dylibs. Add all dylibs, as well as their
  // dependencies, ensuring there are no conflicts. The only valid case for a
  // dependency to be relied upon twice is for both cases to rely on a dylib.
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
  if tcx.dep_kind(cnum).macros_only() {
  continue;
  }
@@ -182,7 +182,7 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
  }
 
  // Collect what we've got so far in the return vector.
- let last_crate = tcx.crates(()).len();
+ let last_crate = tcx.used_crates(()).len();
  let mut ret = (1..last_crate + 1)
  .map(|cnum| match formats.get(&CrateNum::new(cnum)) {
  Some(&RequireDynamic) => Linkage::Dynamic,
@@ -196,7 +196,7 @@ fn calculate_type(tcx: TyCtxt<'_>, ty: CrateType) -> DependencyList {
  //
  // If the crate hasn't been included yet and it's not actually required
  // (e.g., it's an allocator) then we skip it here as well.
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
  let src = tcx.used_crate_source(cnum);
  if src.dylib.is_none()
  && !formats.contains_key(&cnum)
@@ -284,7 +284,7 @@ fn add_library(
 
 fn attempt_static(tcx: TyCtxt<'_>, unavailable: &mut Vec<CrateNum>) -> Option<DependencyList> {
  let all_crates_available_as_rlib = tcx
- .crates(())
+ .used_crates(())
  .iter()
  .copied()
  .filter_map(|cnum| {
@@ -305,7 +305,7 @@ fn attempt_static(tcx: TyCtxt<'_>, unavailable: &mut Vec<CrateNum>) -> Option<De
  // All crates are available in an rlib format, so we're just going to link
  // everything in explicitly so long as it's actually required.
  let mut ret = tcx
- .crates(())
+ .used_crates(())
  .iter()
  .map(|&cnum| match tcx.dep_kind(cnum) {
  CrateDepKind::Explicit => Linkage::Static,

compiler/rustc_metadata/src/errors.rs

@@ -142,8 +142,8 @@ pub struct LinkFrameworkApple {
 }
 
 #[derive(Diagnostic)]
-#[diag(metadata_framework_only_windows, code = E0455)]
-pub struct FrameworkOnlyWindows {
+#[diag(metadata_raw_dylib_only_windows, code = E0455)]
+pub struct RawDylibOnlyWindows {
  #[primary_span]
  pub span: Span,
 }

compiler/rustc_metadata/src/native_libs.rs

@@ -151,7 +151,7 @@ impl<'tcx> Collector<'tcx> {
  }
  "raw-dylib" => {
  if !sess.target.is_like_windows {
- sess.dcx().emit_err(errors::FrameworkOnlyWindows { span });
+ sess.dcx().emit_err(errors::RawDylibOnlyWindows { span });
  }
  NativeLibKind::RawDylib
  }

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -435,7 +435,7 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
  // traversal, but not globally minimal across all crates.
  let bfs_queue = &mut VecDeque::new();
 
- for &cnum in tcx.crates(()) {
+ for &cnum in tcx.crates_including_speculative(()) {
  // Ignore crates without a corresponding local `extern crate` item.
  if tcx.missing_extern_crate_item(cnum) {
  continue;
@@ -505,7 +505,7 @@ pub(in crate::rmeta) fn provide(providers: &mut Providers) {
  tcx.arena
  .alloc_slice(&CStore::from_tcx(tcx).crate_dependencies_in_postorder(LOCAL_CRATE))
  },
- crates: |tcx, ()| {
+ crates_including_speculative: |tcx, ()| {
  // The list of loaded crates is now frozen in query cache,
  // so make sure cstore is not mutably accessed from here on.
  tcx.untracked().cstore.freeze();

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1898,7 +1898,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
  let deps = self
  .tcx
- .crates(())
+ .crates_including_speculative(())
  .iter()
  .map(|&cnum| {
  let dep = CrateDep {

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

@@ -1016,7 +1016,7 @@ pub(super) fn crate_hash(tcx: TyCtxt<'_>, _: LocalCrate) -> Svh {
  let krate = tcx.hir_crate(());
  let hir_body_hash = krate.opt_hir_hash.expect("HIR hash missing while computing crate hash");
 
- let upstream_crates = upstream_crates(tcx);
+ let upstream_crates = upstream_crates_for_hashing(tcx);
 
  let resolutions = tcx.resolutions(());
 
@@ -1085,9 +1085,9 @@ pub(super) fn crate_hash(tcx: TyCtxt<'_>, _: LocalCrate) -> Svh {
  Svh::new(crate_hash)
 }
 
-fn upstream_crates(tcx: TyCtxt<'_>) -> Vec<(StableCrateId, Svh)> {
+fn upstream_crates_for_hashing(tcx: TyCtxt<'_>) -> Vec<(StableCrateId, Svh)> {
  let mut upstream_crates: Vec<_> = tcx
- .crates(())
+ .crates_including_speculative(())
  .iter()
  .map(|&cnum| {
  let stable_crate_id = tcx.stable_crate_id(cnum);

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

@@ -66,6 +66,9 @@ impl ReportedErrorInfo {
  pub fn tainted_by_errors(error: ErrorGuaranteed) -> ReportedErrorInfo {
  ReportedErrorInfo { is_tainted_by_errors: true, error }
  }
+ pub fn is_tainted_by_errors(&self) -> bool {
+ self.is_tainted_by_errors
+ }
 }
 
 impl From<ErrorGuaranteed> for ReportedErrorInfo {

compiler/rustc_middle/src/query/mod.rs

@@ -1860,13 +1860,22 @@ rustc_queries! {
  eval_always
  desc { "calculating the stability index for the local crate" }
  }
- query crates(_: ()) -> &'tcx [CrateNum] {
+ /// All loaded crates, including those loaded purely for doc links or diagnostics.
+ /// (Diagnostics include lints, so speculatively loaded crates may occur in successful
+ /// compilation even without doc links.)
+ /// Should be used when encoding crate metadata (and therefore when generating crate hash,
+ /// depinfo and similar things), to avoid dangling crate references in other encoded data,
+ /// like source maps.
+ /// May also be used for diagnostics - if we are loading a crate anyway we can suggest some
+ /// items from it as well.
+ /// But otherwise, `used_crates` should generally be used.
+ query crates_including_speculative(_: ()) -> &'tcx [CrateNum] {
  eval_always
  desc { "fetching all foreign CrateNum instances" }
  }
- // Crates that are loaded non-speculatively (not for diagnostics or doc links).
- // FIXME: This is currently only used for collecting lang items, but should be used instead of
- // `crates` in most other cases too.
+ /// Crates that are loaded non-speculatively (not for diagnostics or doc links).
+ /// Should be used to maintain observable language behavior, for example when collecting lang
+ /// items or impls from all crates, or collecting libraries to link.
  query used_crates(_: ()) -> &'tcx [CrateNum] {
  eval_always
  desc { "fetching `CrateNum`s for all crates loaded non-speculatively" }

compiler/rustc_middle/src/ty/context.rs

@@ -1611,7 +1611,7 @@ impl<'tcx> TyCtxt<'tcx> {
 
  pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
  iter::once(LOCAL_CRATE)
- .chain(self.crates(()).iter().copied())
+ .chain(self.used_crates(()).iter().copied())
  .flat_map(move |cnum| self.traits(cnum).iter().copied())
  }
 

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

@@ -3258,7 +3258,7 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N
  let queue = &mut Vec::new();
  let mut seen_defs: DefIdSet = Default::default();
 
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.crates_including_speculative(()).iter() {
  let def_id = cnum.as_def_id();
 
  // Ignore crates that are not direct dependencies.