Auto merge of #127614 - matthiaskrgr:rollup-8geziwi, r=matthiaskrgr

Rollup of 8 pull requests Successful merges: - #124599 (Suggest borrowing on fn argument that is `impl AsRef`) - #127572 (Don't mark `DEBUG_EVENT` struct as `repr(packed)`) - #127588 (core: Limit remaining f16 doctests to x86_64 linux) - #127591 (Make sure that labels are defined after the primary span in diagnostics) - #127598 (Allows `#[diagnostic::do_not_recommend]` to supress trait impls in suggestions as well) - #127599 (Rename `lazy_cell_consume` to `lazy_cell_into_inner`) - #127601 (check is_ident before parse_ident) - #127605 (Remove extern "wasm" ABI) r? `@ghost` `@rustbot` modify labels: rollup
rust-lang · Jul 11, 2024 · 5e311f9 · 5e311f9
2 parents 5315cbe fa3ce50
commit 5e311f9
Show file tree

Hide file tree

Showing 45 changed files with 447 additions and 409 deletions.
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -445,31 445,81 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  } else {
  (None, &[][..], 0)
  };
  let mut can_suggest_clone = true;
  if let Some(def_id) = def_id
  && let node = self.infcx.tcx.hir_node_by_def_id(def_id)
  && let Some(fn_sig) = node.fn_sig()
  && let Some(ident) = node.ident()
  && let Some(pos) = args.iter().position(|arg| arg.hir_id == expr.hir_id)
  && let Some(arg) = fn_sig.decl.inputs.get(pos offset)
  {
- let mut span: MultiSpan = arg.span.into();
- span.push_span_label(
- arg.span,
- "this parameter takes ownership of the value".to_string(),
- );
- let descr = match node.fn_kind() {
- Some(hir::intravisit::FnKind::ItemFn(..)) | None => "function",
- Some(hir::intravisit::FnKind::Method(..)) => "method",
- Some(hir::intravisit::FnKind::Closure) => "closure",
- };
- span.push_span_label(ident.span, format!("in this {descr}"));
- err.span_note(
- span,
- format!(
- "consider changing this parameter type in {descr} `{ident}` to borrow \
- instead if owning the value isn't necessary",
- ),
- );
  let mut is_mut = false;
  if let hir::TyKind::Path(hir::QPath::Resolved(None, path)) = arg.kind
  && let Res::Def(DefKind::TyParam, param_def_id) = path.res
  && self
  .infcx
  .tcx
  .predicates_of(def_id)
  .instantiate_identity(self.infcx.tcx)
  .predicates
  .into_iter()
  .any(|pred| {
  if let ty::ClauseKind::Trait(predicate) = pred.kind().skip_binder()
  && [
  self.infcx.tcx.get_diagnostic_item(sym::AsRef),
  self.infcx.tcx.get_diagnostic_item(sym::AsMut),
  self.infcx.tcx.get_diagnostic_item(sym::Borrow),
  self.infcx.tcx.get_diagnostic_item(sym::BorrowMut),
  ]
  .contains(&Some(predicate.def_id()))
  && let ty::Param(param) = predicate.self_ty().kind()
  && let generics = self.infcx.tcx.generics_of(def_id)
  && let param = generics.type_param(*param, self.infcx.tcx)
  && param.def_id == param_def_id
  {
  if [
  self.infcx.tcx.get_diagnostic_item(sym::AsMut),
  self.infcx.tcx.get_diagnostic_item(sym::BorrowMut),
  ]
  .contains(&Some(predicate.def_id()))
  {
  is_mut = true;
  }
  true
  } else {
  false
  }
  })
  {
  // The type of the argument corresponding to the expression that got moved
  // is a type parameter `T`, which is has a `T: AsRef` obligation.
  err.span_suggestion_verbose(
  expr.span.shrink_to_lo(),
  "borrow the value to avoid moving it",
  format!("&{}", if is_mut { "mut " } else { "" }),
  Applicability::MachineApplicable,
  );
  can_suggest_clone = is_mut;
  } else {
  let mut span: MultiSpan = arg.span.into();
  span.push_span_label(
  arg.span,
  "this parameter takes ownership of the value".to_string(),
  );
  let descr = match node.fn_kind() {
  Some(hir::intravisit::FnKind::ItemFn(..)) | None => "function",
  Some(hir::intravisit::FnKind::Method(..)) => "method",
  Some(hir::intravisit::FnKind::Closure) => "closure",
  };
  span.push_span_label(ident.span, format!("in this {descr}"));
  err.span_note(
  span,
  format!(
  "consider changing this parameter type in {descr} `{ident}` to \
  borrow instead if owning the value isn't necessary",
  ),
  );
  }
  }
  let place = &self.move_data.move_paths[mpi].place;
  let ty = place.ty(self.body, self.infcx.tcx).ty;
@@ -487,9 537,10 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
  ClosureKind::Coroutine(CoroutineKind::Desugared(_, CoroutineSource::Block)),
  ..
  } = move_spans
  && can_suggest_clone
  {
  self.suggest_cloning(err, ty, expr, None, Some(move_spans));
- } else if self.suggest_hoisting_call_outside_loop(err, expr) {
  } else if self.suggest_hoisting_call_outside_loop(err, expr) && can_suggest_clone {
  // The place where the type moves would be misleading to suggest clone.
  // #121466
  self.suggest_cloning(err, ty, expr, None, Some(move_spans));

diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -6,7 6,6 @@ use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, PatchableFuncti
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::config::{FunctionReturn, OptLevel};
 use rustc_span::symbol::sym;
-use rustc_target::spec::abi::Abi;
 use rustc_target::spec::{FramePointer, SanitizerSet, StackProbeType, StackProtector};
 use smallvec::SmallVec;
 
@@ -482,7 481,7 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  return;
  }
 
- let mut function_features = function_features
  let function_features = function_features
  .iter()
  .flat_map(|feat| {
  llvm_util::to_llvm_features(cx.tcx.sess, feat).into_iter().map(|f| format!(" {f}"))
@@ -504,17 503,6 @@ pub fn from_fn_attrs<'ll, 'tcx>(
  let name = name.as_str();
  to_add.push(llvm::CreateAttrStringValue(cx.llcx, "wasm-import-name", name));
  }
-
- // The `"wasm"` abi on wasm targets automatically enables the
- // ` multivalue` feature because the purpose of the wasm abi is to match
- // the WebAssembly specification, which has this feature. This won't be
- // needed when LLVM enables this `multivalue` feature by default.
- if !cx.tcx.is_closure_like(instance.def_id()) {
- let abi = cx.tcx.fn_sig(instance.def_id()).skip_binder().abi();
- if abi == Abi::Wasm {
- function_features.push(" multivalue".to_string());
- }
- }
  }
 
  let global_features = cx.tcx.global_backend_features(()).iter().map(|s| s.as_str());

diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
@@ -215,6 215,9 @@ declare_features! (
  /// Permits specifying whether a function should permit unwinding or abort on unwind.
  (removed, unwind_attributes, "1.56.0", Some(58760), Some("use the C-unwind ABI instead")),
  (removed, visible_private_types, "1.0.0", None, None),
  /// Allows `extern "wasm" fn`
  (removed, wasm_abi, "CURRENT_RUSTC_VERSION", Some(83788),
  Some("non-standard wasm ABI is no longer supported")),
  // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!!
  // Features are listed in alphabetical order. Tidy will fail if you don't keep it this way.
  // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!!

diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -640,8 640,6 @@ declare_features! (
  (unstable, unsized_tuple_coercion, "1.20.0", Some(42877)),
  /// Allows using the `#[used(linker)]` (or `#[used(compiler)]`) attribute.
  (unstable, used_with_arg, "1.60.0", Some(93798)),
- /// Allows `extern "wasm" fn`
- (unstable, wasm_abi, "1.53.0", Some(83788)),
  /// Allows `do yeet` expressions
  (unstable, yeet_expr, "1.62.0", Some(96373)),
  // !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!! !!!!

diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
@@ -269,6 269,7 @@ impl DiagnosticDeriveVariantBuilder {
  let field_binding = &binding_info.binding;
 
  let inner_ty = FieldInnerTy::from_type(&field.ty);
  let mut seen_label = false;
 
  field
  .attrs
@@ -280,6 281,14 @@ impl DiagnosticDeriveVariantBuilder {
  }
 
  let name = attr.path().segments.last().unwrap().ident.to_string();
 
  if name == "primary_span" && seen_label {
  span_err(attr.span().unwrap(), format!("`#[primary_span]` must be placed before labels, since it overwrites the span of the diagnostic")).emit();
  }
  if name == "label" {
  seen_label = true;
  }
 
  let needs_clone =
  name == "primary_span" && matches!(inner_ty, FieldInnerTy::Vec(_));
  let (binding, needs_destructure) = if needs_clone {

diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
@@ -1212,7 1212,6 @@ pub fn fn_can_unwind(tcx: TyCtxt<'_>, fn_def_id: Option<DefId>, abi: SpecAbi) ->
  | RiscvInterruptM
  | RiscvInterruptS
  | CCmseNonSecureCall
- | Wasm
  | Unadjusted => false,
  Rust | RustCall | RustCold | RustIntrinsic => {
  tcx.sess.panic_strategy() == PanicStrategy::Unwind

diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -387,8 387,8 @@ impl<'a> Parser<'a> {
  let span = if is_pub { self.prev_token.span.to(ident_span) } else { ident_span };
  let insert_span = ident_span.shrink_to_lo();
 
- let ident = if (!is_const
- || self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Parenthesis)))
  let ident = if self.token.is_ident()
  && (!is_const || self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Parenthesis)))
  && self.look_ahead(1, |t| {
  [
  token::Lt,

diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
@@ -1089,8 1089,8 @@ pub(crate) struct ToolWasAlreadyRegistered {
 #[derive(Diagnostic)]
 #[diag(resolve_tool_only_accepts_identifiers)]
 pub(crate) struct ToolOnlyAcceptsIdentifiers {
- #[label]
  #[primary_span]
  #[label]
  pub(crate) span: Span,
  pub(crate) tool: Symbol,
 }

diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/rustc_internal/internal.rs
@@ -466,7 466,6 @@ impl RustcInternal for Abi {
  Abi::AvrInterrupt => rustc_target::spec::abi::Abi::AvrInterrupt,
  Abi::AvrNonBlockingInterrupt => rustc_target::spec::abi::Abi::AvrNonBlockingInterrupt,
  Abi::CCmseNonSecureCall => rustc_target::spec::abi::Abi::CCmseNonSecureCall,
- Abi::Wasm => rustc_target::spec::abi::Abi::Wasm,
  Abi::System { unwind } => rustc_target::spec::abi::Abi::System { unwind },
  Abi::RustIntrinsic => rustc_target::spec::abi::Abi::RustIntrinsic,
  Abi::RustCall => rustc_target::spec::abi::Abi::RustCall,

diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -909,7 909,6 @@ impl<'tcx> Stable<'tcx> for rustc_target::spec::abi::Abi {
  abi::Abi::AvrInterrupt => Abi::AvrInterrupt,
  abi::Abi::AvrNonBlockingInterrupt => Abi::AvrNonBlockingInterrupt,
  abi::Abi::CCmseNonSecureCall => Abi::CCmseNonSecureCall,
- abi::Abi::Wasm => Abi::Wasm,
  abi::Abi::System { unwind } => Abi::System { unwind },
  abi::Abi::RustIntrinsic => Abi::RustIntrinsic,
  abi::Abi::RustCall => Abi::RustCall,

diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs
@@ -1,6 1,6 @@
 use crate::abi::{self, Abi, Align, FieldsShape, Size};
 use crate::abi::{HasDataLayout, TyAbiInterface, TyAndLayout};
-use crate::spec::{self, HasTargetSpec, HasWasmCAbiOpt};
 use crate::spec::{self, HasTargetSpec, HasWasmCAbiOpt, WasmCAbi};
 use rustc_macros::HashStable_Generic;
 use rustc_span::Symbol;
 use std::fmt;
@@ -854,7 854,8 @@ impl<'a, Ty> FnAbi<'a, Ty> {
  return Ok(());
  }
 
- match &cx.target_spec().arch[..] {
  let spec = cx.target_spec();
  match &spec.arch[..] {
  "x86" => {
  let flavor = if let spec::abi::Abi::Fastcall { .. }
  | spec::abi::Abi::Vectorcall { .. } = abi
@@ -901,9 902,7 @@ impl<'a, Ty> FnAbi<'a, Ty> {
  "sparc" => sparc::compute_abi_info(cx, self),
  "sparc64" => sparc64::compute_abi_info(cx, self),
  "nvptx64" => {
- if cx.target_spec().adjust_abi(cx, abi, self.c_variadic)
- == spec::abi::Abi::PtxKernel
- {
  if cx.target_spec().adjust_abi(abi, self.c_variadic) == spec::abi::Abi::PtxKernel {
  nvptx64::compute_ptx_kernel_abi_info(cx, self)
  } else {
  nvptx64::compute_abi_info(self)
@@ -912,13 911,14 @@ impl<'a, Ty> FnAbi<'a, Ty> {
  "hexagon" => hexagon::compute_abi_info(self),
  "xtensa" => xtensa::compute_abi_info(cx, self),
  "riscv32" | "riscv64" => riscv::compute_abi_info(cx, self),
- "wasm32" | "wasm64" => {
- if cx.target_spec().adjust_abi(cx, abi, self.c_variadic) == spec::abi::Abi::Wasm {
  "wasm32" => {
  if spec.os == "unknown" && cx.wasm_c_abi_opt() == WasmCAbi::Legacy {
  wasm::compute_wasm_abi_info(self)
  } else {
  wasm::compute_c_abi_info(cx, self)
  }
  }
  "wasm64" => wasm::compute_c_abi_info(cx, self),
  "bpf" => bpf::compute_abi_info(self),
  arch => {
  return Err(AdjustForForeignAbiError::Unsupported {

diff --git a/compiler/rustc_target/src/spec/abi/mod.rs b/compiler/rustc_target/src/spec/abi/mod.rs
@@ -48,7 48,6 @@ pub enum Abi {
  AvrInterrupt,
  AvrNonBlockingInterrupt,
  CCmseNonSecureCall,
- Wasm,
  System {
  unwind: bool,
  },
@@ -123,7 122,6 @@ const AbiDatas: &[AbiData] = &[
  AbiData { abi: Abi::AvrInterrupt, name: "avr-interrupt" },
  AbiData { abi: Abi::AvrNonBlockingInterrupt, name: "avr-non-blocking-interrupt" },
  AbiData { abi: Abi::CCmseNonSecureCall, name: "C-cmse-nonsecure-call" },
- AbiData { abi: Abi::Wasm, name: "wasm" },
  AbiData { abi: Abi::System { unwind: false }, name: "system" },
  AbiData { abi: Abi::System { unwind: true }, name: "system-unwind" },
  AbiData { abi: Abi::RustIntrinsic, name: "rust-intrinsic" },
@@ -149,6 147,9 @@ pub fn lookup(name: &str) -> Result<Abi, AbiUnsupported> {
  "riscv-interrupt-u" => AbiUnsupported::Reason {
  explain: "user-mode interrupt handlers have been removed from LLVM pending standardization, see: https://reviews.llvm.org/D149314",
  },
  "wasm" => AbiUnsupported::Reason {
  explain: "non-standard wasm ABI is no longer supported",
  },
 
  _ => AbiUnsupported::Unrecognized,
 
@@ -241,10 242,6 @@ pub fn is_stable(name: &str) -> Result<(), AbiDisabled> {
  feature: sym::abi_c_cmse_nonsecure_call,
  explain: "C-cmse-nonsecure-call ABI is experimental and subject to change",
  }),
- "wasm" => Err(AbiDisabled::Unstable {
- feature: sym::wasm_abi,
- explain: "wasm ABI is experimental and subject to change",
- }),
  _ => Err(AbiDisabled::Unrecognized),
  }
 }
@@ -287,16 284,15 @@ impl Abi {
  AvrInterrupt => 23,
  AvrNonBlockingInterrupt => 24,
  CCmseNonSecureCall => 25,
- Wasm => 26,
  // Cross-platform ABIs
- System { unwind: false } => 27,
- System { unwind: true } => 28,
- RustIntrinsic => 29,
- RustCall => 30,
- Unadjusted => 31,
- RustCold => 32,
- RiscvInterruptM => 33,
- RiscvInterruptS => 34,
  System { unwind: false } => 26,
  System { unwind: true } => 27,
  RustIntrinsic => 28,
  RustCall => 29,
  Unadjusted => 30,
  RustCold => 31,
  RiscvInterruptM => 32,
  RiscvInterruptS => 33,
  };
  debug_assert!(
  AbiDatas

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
@@ -2608,22 2608,8 @@ impl DerefMut for Target {
 
 impl Target {
  /// Given a function ABI, turn it into the correct ABI for this target.
- pub fn adjust_abi<C>(&self, cx: &C, abi: Abi, c_variadic: bool) -> Abi
- where
- C: HasWasmCAbiOpt,
- {
  pub fn adjust_abi(&self, abi: Abi, c_variadic: bool) -> Abi {
  match abi {
- Abi::C { .. } => {
- if self.arch == "wasm32"
- && self.os == "unknown"
- && cx.wasm_c_abi_opt() == WasmCAbi::Legacy
- {
- Abi::Wasm
- } else {
- abi
- }
- }
-
  // On Windows, `extern "system"` behaves like msvc's `__stdcall`.
  // `__stdcall` only applies on x86 and on non-variadic functions:
  // https://learn.microsoft.com/en-us/cpp/cpp/stdcall?view=msvc-170
@@ -2676,7 2662,6 @@ impl Target {
  Msp430Interrupt => self.arch == "msp430",
  RiscvInterruptM | RiscvInterruptS => ["riscv32", "riscv64"].contains(&&self.arch[..]),
  AvrInterrupt | AvrNonBlockingInterrupt => self.arch == "avr",
- Wasm => ["wasm32", "wasm64"].contains(&&self.arch[..]),
  Thiscall { .. } => self.arch == "x86",
  // On windows these fall-back to platform native calling convention (C) when the
  // architecture is not supported.