Auto merge of rust-lang#131785 - Urgau:rollup-v431zf4, r=Urgau

Rollup of 10 pull requests

Successful merges:

 - rust-lang#129181 (Pass end position of span through inline ASM cookie)
 - rust-lang#130989 (Don't check unsize goal in MIR validation when opaques remain)
 - rust-lang#131657 (Rustfmt `for<'a> async` correctly)
 - rust-lang#131691 (Delay ambiguous intra-doc link resolution after `Cache` has been populated)
 - rust-lang#131730 (Refactor some `core::fmt` macros)
 - rust-lang#131751 (Rename `can_coerce` to `may_coerce`, and then structurally resolve correctly in the probe)
 - rust-lang#131753 (Unify `secondary_span` and `swap_secondary_and_primary` args in `note_type_err`)
 - rust-lang#131776 (Emscripten: Xfail backtrace ui tests)
 - rust-lang#131777 (Fix trivially_copy_pass_by_ref in stable_mir)
 - rust-lang#131778 (Fix needless_lifetimes in stable_mir)

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

compiler/rustc_codegen_llvm/src/asm.rs

@@ -487,14 +487,13 @@ pub(crate) fn inline_asm_call<'ll>(
  let key = "srcloc";
  let kind = llvm::LLVMGetMDKindIDInContext(
  bx.llcx,
- key.as_ptr() as *const c_char,
+ key.as_ptr().cast::<c_char>(),
  key.len() as c_uint,
  );
 
- // srcloc contains one integer for each line of assembly code.
- // Unfortunately this isn't enough to encode a full span so instead
- // we just encode the start position of each line.
- // FIXME: Figure out a way to pass the entire line spans.
+ // `srcloc` contains one 64-bit integer for each line of assembly code,
+ // where the lower 32 bits hold the lo byte position and the upper 32 bits
+ // hold the hi byte position.
  let mut srcloc = vec![];
  if dia == llvm::AsmDialect::Intel && line_spans.len() > 1 {
  // LLVM inserts an extra line to add the ".intel_syntax", so add
@@ -504,13 +503,13 @@ pub(crate) fn inline_asm_call<'ll>(
  // due to the asm template string coming from a macro. LLVM will
  // default to the first srcloc for lines that don't have an
  // associated srcloc.
- srcloc.push(llvm::LLVMValueAsMetadata(bx.const_i32(0)));
+ srcloc.push(llvm::LLVMValueAsMetadata(bx.const_u64(0)));
  }
- srcloc.extend(
- line_spans
- .iter()
-  .map(|span| llvm::LLVMValueAsMetadata(bx.const_i32(span.lo().to_u32() as i32))),
- );
+ srcloc.extend(line_spans.iter().map(|span| {
+ llvm::LLVMValueAsMetadata(bx.const_u64(
+ u64::from(span.lo().to_u32()) | (u64::from(span.hi().to_u32()) << 32),
+ ))
+ }));
  let md = llvm::LLVMMDNodeInContext2(bx.llcx, srcloc.as_ptr(), srcloc.len());
  let md = llvm::LLVMMetadataAsValue(&bx.llcx, md);
  llvm::LLVMSetMetadata(call, kind, md);

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -24,8 +24,8 @@ use rustc_session::Session;
 use rustc_session::config::{
  self, Lto, OutputType, Passes, RemapPathScopeComponents, SplitDwarfKind, SwitchWithOptPath,
 };
-use rustc_span::InnerSpan;
 use rustc_span::symbol::sym;
+use rustc_span::{BytePos, InnerSpan, Pos, SpanData, SyntaxContext};
 use rustc_target::spec::{CodeModel, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel};
 use tracing::debug;
 
@@ -411,21 +411,32 @@ fn report_inline_asm(
  cgcx: &CodegenContext<LlvmCodegenBackend>,
  msg: String,
  level: llvm::DiagnosticLevel,
- mut cookie: u64,
+ cookie: u64,
  source: Option<(String, Vec<InnerSpan>)>,
 ) {
  // In LTO build we may get srcloc values from other crates which are invalid
  // since they use a different source map. To be safe we just suppress these
  // in LTO builds.
- if matches!(cgcx.lto, Lto::Fat | Lto::Thin) {
- cookie = 0;
- }
+ let span = if cookie == 0 || matches!(cgcx.lto, Lto::Fat | Lto::Thin) {
+ SpanData::default()
+ } else {
+ let lo = BytePos::from_u32(cookie as u32);
+ let hi = BytePos::from_u32((cookie >> 32) as u32);
+ SpanData {
+ lo,
+ // LLVM version < 19 silently truncates the cookie to 32 bits in some situations.
+ hi: if hi.to_u32() != 0 { hi } else { lo },
+ ctxt: SyntaxContext::root(),
+ parent: None,
+ }
+ };
  let level = match level {
  llvm::DiagnosticLevel::Error => Level::Error,
  llvm::DiagnosticLevel::Warning => Level::Warning,
  llvm::DiagnosticLevel::Note | llvm::DiagnosticLevel::Remark => Level::Note,
  };
- cgcx.diag_emitter.inline_asm_error(cookie.try_into().unwrap(), msg, level, source);
+ let msg = msg.strip_prefix("error: ").unwrap_or(&msg).to_string();
+ cgcx.diag_emitter.inline_asm_error(span, msg, level, source);
 }
 
 unsafe extern "C" fn diagnostic_handler(info: &DiagnosticInfo, user: *mut c_void) {

compiler/rustc_codegen_llvm/src/llvm/diagnostic.rs

@@ -151,7 +151,7 @@ impl InlineAsmDiagnostic {
  unsafe { SrcMgrDiagnostic::unpack(super::LLVMRustGetSMDiagnostic(di, &mut cookie)) };
  InlineAsmDiagnostic {
  level: smdiag.level,
- cookie: cookie.into(),
+ cookie,
  message: smdiag.message,
  source: smdiag.source,
  }

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2271,7 +2271,7 @@ unsafe extern "C" {
 
  pub fn LLVMRustGetSMDiagnostic<'a>(
  DI: &'a DiagnosticInfo,
- cookie_out: &mut c_uint,
+ cookie_out: &mut u64,
  ) -> &'a SMDiagnostic;
 
  #[allow(improper_ctypes)]

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -34,7 +34,7 @@ use rustc_session::config::{
 };
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::sym;
-use rustc_span::{BytePos, FileName, InnerSpan, Pos, Span};
+use rustc_span::{FileName, InnerSpan, Span, SpanData};
 use rustc_target::spec::{MergeFunctions, SanitizerSet};
 use tracing::debug;
 
@@ -1852,7 +1852,7 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
 
 enum SharedEmitterMessage {
  Diagnostic(Diagnostic),
- InlineAsmError(u32, String, Level, Option<(String, Vec<InnerSpan>)>),
+ InlineAsmError(SpanData, String, Level, Option<(String, Vec<InnerSpan>)>),
  Fatal(String),
 }
 
@@ -1874,12 +1874,12 @@ impl SharedEmitter {
 
  pub fn inline_asm_error(
  &self,
- cookie: u32,
+ span: SpanData,
  msg: String,
  level: Level,
  source: Option<(String, Vec<InnerSpan>)>,
  ) {
- drop(self.sender.send(SharedEmitterMessage::InlineAsmError(cookie, msg, level, source)));
+ drop(self.sender.send(SharedEmitterMessage::InlineAsmError(span, msg, level, source)));
  }
 
  fn fatal(&self, msg: &str) {
@@ -1964,17 +1964,12 @@ impl SharedEmitterMain {
  dcx.emit_diagnostic(d);
  sess.dcx().abort_if_errors();
  }
- Ok(SharedEmitterMessage::InlineAsmError(cookie, msg, level, source)) => {
+ Ok(SharedEmitterMessage::InlineAsmError(span, msg, level, source)) => {
  assert_matches!(level, Level::Error | Level::Warning | Level::Note);
- let msg = msg.strip_prefix("error: ").unwrap_or(&msg).to_string();
  let mut err = Diag::<()>::new(sess.dcx(), level, msg);
-
- // If the cookie is 0 then we don't have span information.
- if cookie != 0 {
- let pos = BytePos::from_u32(cookie);
- let span = Span::with_root_ctxt(pos, pos);
- err.span(span);
- };
+ if !span.is_dummy() {
+ err.span(span.span());
+ }
 
  // Point to the generated assembly if it is available.
  if let Some((buffer, spans)) = source {

compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

@@ -592,14 +592,13 @@ pub(super) fn collect_return_position_impl_trait_in_trait_tys<'tcx>(
  &cause,
  hir.get_if_local(impl_m.def_id)
  .and_then(|node| node.fn_decl())
- .map(|decl| (decl.output.span(), Cow::from("return type in trait"))),
+ .map(|decl| (decl.output.span(), Cow::from("return type in trait"), false)),
  Some(infer::ValuePairs::Terms(ExpectedFound {
  expected: trait_return_ty.into(),
  found: impl_return_ty.into(),
  })),
  terr,
  false,
- false,
  );
  return Err(diag.emit());
  }
@@ -1018,14 +1017,13 @@ fn report_trait_method_mismatch<'tcx>(
  infcx.err_ctxt().note_type_err(
  &mut diag,
  &cause,
- trait_err_span.map(|sp| (sp, Cow::from("type in trait"))),
+ trait_err_span.map(|sp| (sp, Cow::from("type in trait"), false)),
  Some(infer::ValuePairs::PolySigs(ExpectedFound {
  expected: ty::Binder::dummy(trait_sig),
  found: ty::Binder::dummy(impl_sig),
  })),
  terr,
  false,
- false,
  );
 
  diag.emit()
@@ -1825,14 +1823,13 @@ fn compare_const_predicate_entailment<'tcx>(
  infcx.err_ctxt().note_type_err(
  &mut diag,
  &cause,
- trait_c_span.map(|span| (span, Cow::from("type in trait"))),
+ trait_c_span.map(|span| (span, Cow::from("type in trait"), false)),
  Some(infer::ValuePairs::Terms(ExpectedFound {
  expected: trait_ty.into(),
  found: impl_ty.into(),
  })),
  terr,
  false,
- false,
  );
  return Err(diag.emit());
  };

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -652,7 +652,6 @@ pub fn check_function_signature<'tcx>(
  })),
  err,
  false,
- false,
  );
  return Err(diag.emit());
  }

compiler/rustc_hir_typeck/src/_match.rs

@@ -235,8 +235,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  Some(ret_coercion) => {
  let ret_ty = ret_coercion.borrow().expected_ty();
  let ret_ty = self.infcx.shallow_resolve(ret_ty);
- self.can_coerce(arm_ty, ret_ty)
- && prior_arm.is_none_or(|(_, ty, _)| self.can_coerce(ty, ret_ty))
+ self.may_coerce(arm_ty, ret_ty)
+ && prior_arm.is_none_or(|(_, ty, _)| self.may_coerce(ty, ret_ty))
  // The match arms need to unify for the case of `impl Trait`.
  && !matches!(ret_ty.kind(), ty::Alias(ty::Opaque, ..))
  }

compiler/rustc_hir_typeck/src/cast.rs

@@ -409,7 +409,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
  let mut sugg_mutref = false;
  if let ty::Ref(reg, cast_ty, mutbl) = *self.cast_ty.kind() {
  if let ty::RawPtr(expr_ty, _) = *self.expr_ty.kind()
- && fcx.can_coerce(
+ && fcx.may_coerce(
  Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, expr_ty, mutbl),
  self.cast_ty,
  )
@@ -418,22 +418,22 @@ impl<'a, 'tcx> CastCheck<'tcx> {
  } else if let ty::Ref(expr_reg, expr_ty, expr_mutbl) = *self.expr_ty.kind()
  && expr_mutbl == Mutability::Not
  && mutbl == Mutability::Mut
- && fcx.can_coerce(Ty::new_mut_ref(fcx.tcx, expr_reg, expr_ty), self.cast_ty)
+ && fcx.may_coerce(Ty::new_mut_ref(fcx.tcx, expr_reg, expr_ty), self.cast_ty)
  {
  sugg_mutref = true;
  }
 
  if !sugg_mutref
  && sugg == None
- && fcx.can_coerce(
+ && fcx.may_coerce(
  Ty::new_ref(fcx.tcx, reg, self.expr_ty, mutbl),
  self.cast_ty,
  )
  {
  sugg = Some((format!("&{}", mutbl.prefix_str()), false));
  }
  } else if let ty::RawPtr(_, mutbl) = *self.cast_ty.kind()
- && fcx.can_coerce(
+ && fcx.may_coerce(
  Ty::new_ref(fcx.tcx, fcx.tcx.lifetimes.re_erased, self.expr_ty, mutbl),
  self.cast_ty,
  )

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1084,24 +1084,42 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  })
  }
 
- /// Same as `coerce()`, but without side-effects.
+ /// Probe whether `expr_ty` can be coerced to `target_ty`. This has no side-effects,
+ /// and may return false positives if types are not yet fully constrained by inference.
  ///
- /// Returns false if the coercion creates any obligations that result in
- /// errors.
- pub(crate) fn can_coerce(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> bool {
- // FIXME(-Znext-solver): We need to structurally resolve both types here.
- let source = self.resolve_vars_with_obligations(expr_ty);
- debug!("coercion::can_with_predicates({:?} -> {:?})", source, target);
-
+ /// Returns false if the coercion is not possible, or if the coercion creates any
+ /// sub-obligations that result in errors.
+ ///
+ /// This should only be used for diagnostics.
+ pub(crate) fn may_coerce(&self, expr_ty: Ty<'tcx>, target_ty: Ty<'tcx>) -> bool {
  let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable);
  // We don't ever need two-phase here since we throw out the result of the coercion.
  // We also just always set `coerce_never` to true, since this is a heuristic.
- let coerce = Coerce::new(self, cause, AllowTwoPhase::No, true);
+ let coerce = Coerce::new(self, cause.clone(), AllowTwoPhase::No, true);
  self.probe(|_| {
- let Ok(ok) = coerce.coerce(source, target) else {
+ // Make sure to structurally resolve the types, since we use
+ // the `TyKind`s heavily in coercion.
+ let ocx = ObligationCtxt::new(self);
+ let structurally_resolve = |ty| {
+ let ty = self.shallow_resolve(ty);
+ if self.next_trait_solver()
+ && let ty::Alias(..) = ty.kind()
+ {
+ ocx.structurally_normalize(&cause, self.param_env, ty)
+ } else {
+ Ok(ty)
+ }
+ };
+ let Ok(expr_ty) = structurally_resolve(expr_ty) else {
+ return false;
+ };
+ let Ok(target_ty) = structurally_resolve(target_ty) else {
+ return false;
+ };
+
+ let Ok(ok) = coerce.coerce(expr_ty, target_ty) else {
  return false;
  };
- let ocx = ObligationCtxt::new(self);
  ocx.register_obligations(ok.obligations);
  ocx.select_where_possible().is_empty()
  })
@@ -1370,7 +1388,7 @@ pub fn can_coerce<'tcx>(
 ) -> bool {
  let root_ctxt = crate::typeck_root_ctxt::TypeckRootCtxt::new(tcx, body_id);
  let fn_ctxt = FnCtxt::new(&root_ctxt, param_env, body_id);
- fn_ctxt.can_coerce(ty, output_ty)
+ fn_ctxt.may_coerce(ty, output_ty)
 }
 
 /// CoerceMany encapsulates the pattern you should use when you have

compiler/rustc_hir_typeck/src/expr.rs

@@ -1330,9 +1330,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let refs_can_coerce = |lhs: Ty<'tcx>, rhs: Ty<'tcx>| {
  let lhs = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, lhs.peel_refs());
  let rhs = Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, rhs.peel_refs());
- self.can_coerce(rhs, lhs)
+ self.may_coerce(rhs, lhs)
  };
- let (applicability, eq) = if self.can_coerce(rhs_ty, lhs_ty) {
+ let (applicability, eq) = if self.may_coerce(rhs_ty, lhs_ty) {
  (Applicability::MachineApplicable, true)
  } else if refs_can_coerce(rhs_ty, lhs_ty) {
  // The lhs and rhs are likely missing some references in either side. Subsequent
@@ -1349,7 +1349,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let actual_lhs_ty = self.check_expr(rhs_expr);
  (
  Applicability::MaybeIncorrect,
- self.can_coerce(rhs_ty, actual_lhs_ty)
+ self.may_coerce(rhs_ty, actual_lhs_ty)
  || refs_can_coerce(rhs_ty, actual_lhs_ty),
  )
  } else if let ExprKind::Binary(
@@ -1363,7 +1363,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let actual_rhs_ty = self.check_expr(lhs_expr);
  (
  Applicability::MaybeIncorrect,
- self.can_coerce(actual_rhs_ty, lhs_ty)
+ self.may_coerce(actual_rhs_ty, lhs_ty)
  || refs_can_coerce(actual_rhs_ty, lhs_ty),
  )
  } else {
@@ -1414,7 +1414,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  self.param_env,
  )
  .may_apply();
- if lhs_deref_ty_is_sized && self.can_coerce(rhs_ty, lhs_deref_ty) {
+ if lhs_deref_ty_is_sized && self.may_coerce(rhs_ty, lhs_deref_ty) {
  err.span_suggestion_verbose(
  lhs.span.shrink_to_lo(),
  "consider dereferencing here to assign to the mutably borrowed value",