Auto merge of #119927 - matthiaskrgr:rollup-885ws57, r=matthiaskrgr

Rollup of 6 pull requests

Successful merges:

 - #119587 (Varargs support for system ABI)
 - #119891 (rename `reported_signature_mismatch` to reflect its use)
 - #119894 (Allow `~const` on associated type bounds again)
 - #119896 (Taint `_` placeholder types in trait impl method signatures)
 - #119898 (Remove unused `ErrorReporting` variant from overflow handling)
 - #119902 (fix typo in `fn()` docs)

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

compiler/rustc_ast_passes/messages.ftl

@@ -232,6 +232,9 @@ ast_passes_tilde_const_disallowed = `~const` is not allowed here
  .trait = this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
  .trait_impl = this impl is not `const`, so it cannot have `~const` trait bounds
  .impl = inherent impls cannot have `~const` trait bounds
+ .trait_assoc_ty = associated types in non-`#[const_trait]` traits cannot have `~const` trait bounds
+ .trait_impl_assoc_ty = associated types in non-const impls cannot have `~const` trait bounds
+ .inherent_assoc_ty = inherent associated types cannot have `~const` trait bounds
  .object = trait objects cannot have `~const` trait bounds
  .item = this item cannot have `~const` trait bounds
 

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -37,12 +37,17 @@ enum SelfSemantic {
 }
 
 /// What is the context that prevents using `~const`?
+// FIXME(effects): Consider getting rid of this in favor of `errors::TildeConstReason`, they're
+// almost identical. This gets rid of an abstraction layer which might be considered bad.
 enum DisallowTildeConstContext<'a> {
  TraitObject,
  Fn(FnKind<'a>),
  Trait(Span),
  TraitImpl(Span),
  Impl(Span),
+ TraitAssocTy(Span),
+ TraitImplAssocTy(Span),
+ InherentAssocTy(Span),
  Item,
 }
 
@@ -316,6 +321,7 @@ impl<'a> AstValidator<'a> {
  constness: Const::No,
  polarity: ImplPolarity::Positive,
  trait_ref,
+ ..
  } = parent
  {
  Some(trait_ref.path.span.shrink_to_lo())
@@ -1286,6 +1292,15 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  // suggestion for moving such bounds to the assoc const fns if available.
  errors::TildeConstReason::Impl { span }
  }
+ &DisallowTildeConstContext::TraitAssocTy(span) => {
+ errors::TildeConstReason::TraitAssocTy { span }
+ }
+ &DisallowTildeConstContext::TraitImplAssocTy(span) => {
+ errors::TildeConstReason::TraitImplAssocTy { span }
+ }
+ &DisallowTildeConstContext::InherentAssocTy(span) => {
+ errors::TildeConstReason::InherentAssocTy { span }
+ }
  DisallowTildeConstContext::TraitObject => {
  errors::TildeConstReason::TraitObject
  }
@@ -1483,13 +1498,12 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  self.check_item_named(item.ident, "const");
  }
 
+ let parent_is_const =
+ self.outer_trait_or_trait_impl.as_ref().and_then(TraitOrTraitImpl::constness).is_some();
+
  match &item.kind {
  AssocItemKind::Fn(box Fn { sig, generics, body, .. })
- if self
- .outer_trait_or_trait_impl
- .as_ref()
- .and_then(TraitOrTraitImpl::constness)
- .is_some()
+ if parent_is_const
  || ctxt == AssocCtxt::Trait
  || matches!(sig.header.constness, Const::Yes(_)) =>
  {
@@ -1505,6 +1519,20 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
  );
  self.visit_fn(kind, item.span, item.id);
  }
+ AssocItemKind::Type(_) => {
+ let disallowed = (!parent_is_const).then(|| match self.outer_trait_or_trait_impl {
+ Some(TraitOrTraitImpl::Trait { .. }) => {
+ DisallowTildeConstContext::TraitAssocTy(item.span)
+ }
+ Some(TraitOrTraitImpl::TraitImpl { .. }) => {
+ DisallowTildeConstContext::TraitImplAssocTy(item.span)
+ }
+ None => DisallowTildeConstContext::InherentAssocTy(item.span),
+ });
+ self.with_tilde_const(disallowed, |this| {
+ this.with_in_trait_impl(None, |this| visit::walk_assoc_item(this, item, ctxt))
+ })
+ }
  _ => self.with_in_trait_impl(None, |this| visit::walk_assoc_item(this, item, ctxt)),
  }
  }

compiler/rustc_ast_passes/src/errors.rs

@@ -565,6 +565,8 @@ pub struct ConstBoundTraitObject {
  pub span: Span,
 }
 
+// FIXME(effects): Consider making the note/reason the message of the diagnostic.
+// FIXME(effects): Provide structured suggestions (e.g., add `const` / `#[const_trait]` here).
 #[derive(Diagnostic)]
 #[diag(ast_passes_tilde_const_disallowed)]
 pub struct TildeConstDisallowed {
@@ -598,6 +600,21 @@ pub enum TildeConstReason {
  #[primary_span]
  span: Span,
  },
+ #[note(ast_passes_trait_assoc_ty)]
+ TraitAssocTy {
+ #[primary_span]
+ span: Span,
+ },
+ #[note(ast_passes_trait_impl_assoc_ty)]
+ TraitImplAssocTy {
+ #[primary_span]
+ span: Span,
+ },
+ #[note(ast_passes_inherent_assoc_ty)]
+ InherentAssocTy {
+ #[primary_span]
+ span: Span,
+ },
  #[note(ast_passes_object)]
  TraitObject,
  #[note(ast_passes_item)]

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -2659,7 +2659,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  self.suggest_trait_fn_ty_for_impl_fn_infer(hir_id, Some(i))
  {
  infer_replacements.push((a.span, suggested_ty.to_string()));
- return suggested_ty;
+ return Ty::new_error_with_message(
+ self.tcx(),
+ a.span,
+ suggested_ty.to_string(),
+ );
  }
  }
 
@@ -2677,7 +2681,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
  self.suggest_trait_fn_ty_for_impl_fn_infer(hir_id, None)
  {
  infer_replacements.push((output.span, suggested_ty.to_string()));
- suggested_ty
+ Ty::new_error_with_message(self.tcx(), output.span, suggested_ty.to_string())
  } else {
  visitor.visit_ty(output);
  self.ast_ty_to_ty(output)

compiler/rustc_hir_analysis/src/lib.rs

@@ -116,7 +116,8 @@ use rustc_hir::def::DefKind;
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 fn require_c_abi_if_c_variadic(tcx: TyCtxt<'_>, decl: &hir::FnDecl<'_>, abi: Abi, span: Span) {
- const CONVENTIONS_UNSTABLE: &str = "`C`, `cdecl`, `aapcs`, `win64`, `sysv64` or `efiapi`";
+ const CONVENTIONS_UNSTABLE: &str =
+ "`C`, `cdecl`, `system`, `aapcs`, `win64`, `sysv64` or `efiapi`";
  const CONVENTIONS_STABLE: &str = "`C` or `cdecl`";
  const UNSTABLE_EXPLAIN: &str =
  "using calling conventions other than `C` or `cdecl` for varargs functions is unstable";

compiler/rustc_infer/src/infer/at.rs

@@ -84,7 +84,7 @@ impl<'tcx> InferCtxt<'tcx> {
  selection_cache: self.selection_cache.clone(),
  evaluation_cache: self.evaluation_cache.clone(),
  reported_trait_errors: self.reported_trait_errors.clone(),
- reported_closure_mismatch: self.reported_closure_mismatch.clone(),
+ reported_signature_mismatch: self.reported_signature_mismatch.clone(),
  tainted_by_errors: self.tainted_by_errors.clone(),
  err_count_on_creation: self.err_count_on_creation,
  universe: self.universe.clone(),

compiler/rustc_infer/src/infer/mod.rs

@@ -278,7 +278,7 @@ pub struct InferCtxt<'tcx> {
  /// avoid reporting the same error twice.
  pub reported_trait_errors: RefCell<FxIndexMap<Span, Vec<ty::Predicate<'tcx>>>>,
 
- pub reported_closure_mismatch: RefCell<FxHashSet<(Span, Option<Span>)>>,
+ pub reported_signature_mismatch: RefCell<FxHashSet<(Span, Option<Span>)>>,
 
  /// When an error occurs, we want to avoid reporting "derived"
  /// errors that are due to this original failure. Normally, we
@@ -702,7 +702,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
  selection_cache: Default::default(),
  evaluation_cache: Default::default(),
  reported_trait_errors: Default::default(),
- reported_closure_mismatch: Default::default(),
+ reported_signature_mismatch: Default::default(),
  tainted_by_errors: Cell::new(None),
  err_count_on_creation: tcx.dcx().err_count(),
  universe: Cell::new(ty::UniverseIndex::ROOT),

compiler/rustc_metadata/src/native_libs.rs

@@ -520,11 +520,23 @@ impl<'tcx> Collector<'tcx> {
  ) -> DllImport {
  let span = self.tcx.def_span(item);
 
+ // this logic is similar to `Target::adjust_abi` (in rustc_target/src/spec/mod.rs) but errors on unsupported inputs
  let calling_convention = if self.tcx.sess.target.arch == "x86" {
  match abi {
  Abi::C { .. } | Abi::Cdecl { .. } => DllCallingConvention::C,
- Abi::Stdcall { .. } | Abi::System { .. } => {
- DllCallingConvention::Stdcall(self.i686_arg_list_size(item))
+ Abi::Stdcall { .. } => DllCallingConvention::Stdcall(self.i686_arg_list_size(item)),
+ // 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
+ Abi::System { .. } => {
+ let c_variadic =
+ self.tcx.type_of(item).instantiate_identity().fn_sig(self.tcx).c_variadic();
+
+ if c_variadic {
+ DllCallingConvention::C
+ } else {
+ DllCallingConvention::Stdcall(self.i686_arg_list_size(item))
+ }
  }
  Abi::Fastcall { .. } => {
  DllCallingConvention::Fastcall(self.i686_arg_list_size(item))

compiler/rustc_middle/src/traits/mod.rs

@@ -611,9 +611,6 @@ pub enum SelectionError<'tcx> {
  NotConstEvaluatable(NotConstEvaluatable),
  /// Exceeded the recursion depth during type projection.
  Overflow(OverflowError),
- /// Signaling that an error has already been emitted, to avoid
- /// multiple errors being shown.
- ErrorReporting,
  /// Computing an opaque type's hidden type caused an error (e.g. a cycle error).
  /// We can thus not know whether the hidden type implements an auto trait, so
  /// we should not presume anything about it.

compiler/rustc_middle/src/traits/select.rs

@@ -302,7 +302,6 @@ impl EvaluationResult {
 pub enum OverflowError {
  Error(ErrorGuaranteed),
  Canonical,
- ErrorReporting,
 }
 
 impl From<ErrorGuaranteed> for OverflowError {
@@ -318,7 +317,6 @@ impl<'tcx> From<OverflowError> for SelectionError<'tcx> {
  match overflow_error {
  OverflowError::Error(e) => SelectionError::Overflow(OverflowError::Error(e)),
  OverflowError::Canonical => SelectionError::Overflow(OverflowError::Canonical),
- OverflowError::ErrorReporting => SelectionError::ErrorReporting,
  }
  }
 }

compiler/rustc_target/src/abi/call/mod.rs

@@ -840,7 +840,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(abi) == 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)
@@ -849,7 +849,7 @@ impl<'a, Ty> FnAbi<'a, Ty> {
  "hexagon" => hexagon::compute_abi_info(self),
  "riscv32" | "riscv64" => riscv::compute_abi_info(cx, self),
  "wasm32" | "wasm64" => {
- if cx.target_spec().adjust_abi(abi) == spec::abi::Abi::Wasm {
+ if cx.target_spec().adjust_abi(abi, self.c_variadic) == spec::abi::Abi::Wasm {
  wasm::compute_wasm_abi_info(self)
  } else {
  wasm::compute_c_abi_info(cx, self)

compiler/rustc_target/src/spec/abi/mod.rs

@@ -70,15 +70,16 @@ impl Abi {
  // * C and Cdecl obviously support varargs.
  // * C can be based on Aapcs, SysV64 or Win64, so they must support varargs.
  // * EfiApi is based on Win64 or C, so it also supports it.
+ // * System falls back to C for functions with varargs.
  //
  // * Stdcall does not, because it would be impossible for the callee to clean
  // up the arguments. (callee doesn't know how many arguments are there)
  // * Same for Fastcall, Vectorcall and Thiscall.
- // * System can become Stdcall, so is also a no-no.
  // * Other calling conventions are related to hardware or the compiler itself.
  match self {
  Self::C { .. }
  | Self::Cdecl { .. }
+ | Self::System { .. }
  | Self::Aapcs { .. }
  | Self::Win64 { .. }
  | Self::SysV64 { .. }

compiler/rustc_target/src/spec/mod.rs

@@ -2401,10 +2401,14 @@ impl DerefMut for Target {
 
 impl Target {
  /// Given a function ABI, turn it into the correct ABI for this target.
- pub fn adjust_abi(&self, abi: Abi) -> Abi {
+ pub fn adjust_abi(&self, abi: Abi, c_variadic: bool) -> Abi {
  match abi {
  Abi::C { .. } => self.default_adjusted_cabi.unwrap_or(abi),
- Abi::System { unwind } if self.is_like_windows && self.arch == "x86" => {
+
+ // 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
+ Abi::System { unwind } if self.is_like_windows && self.arch == "x86" && !c_variadic => {
  Abi::Stdcall { unwind }
  }
  Abi::System { unwind } => Abi::C { unwind },

compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs

@@ -947,9 +947,6 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  Overflow(_) => {
  bug!("overflow should be handled before the `report_selection_error` path");
  }
- SelectionError::ErrorReporting => {
- bug!("ErrorReporting Overflow should not reach `report_selection_err` call")
- }
  };
 
  self.note_obligation_cause(&mut err, &obligation);
@@ -3459,14 +3456,12 @@ impl<'tcx> InferCtxtPrivExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  let found_node = found_did.and_then(|did| self.tcx.hir().get_if_local(did));
  let found_span = found_did.and_then(|did| self.tcx.hir().span_if_local(did));
 
- if self.reported_closure_mismatch.borrow().contains(&(span, found_span)) {
+ if !self.reported_signature_mismatch.borrow_mut().insert((span, found_span)) {
  // We check closures twice, with obligations flowing in different directions,
  // but we want to complain about them only once.
  return None;
  }
 
- self.reported_closure_mismatch.borrow_mut().insert((span, found_span));
-
  let mut not_tupled = false;
 
  let found = match found_trait_ref.skip_binder().args.type_at(1).kind() {

compiler/rustc_trait_selection/src/traits/query/evaluate_obligation.rs

@@ -116,11 +116,9 @@ impl<'tcx> InferCtxtExt<'tcx> for InferCtxt<'tcx> {
  r,
  )
  }
- OverflowError::ErrorReporting => EvaluationResult::EvaluatedToErr,
  OverflowError::Error(_) => EvaluationResult::EvaluatedToErr,
  })
  }
- Err(OverflowError::ErrorReporting) => EvaluationResult::EvaluatedToErr,
  Err(OverflowError::Error(_)) => EvaluationResult::EvaluatedToErr,
  }
  }

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -14,9 +14,9 @@ use super::util;
 use super::util::closure_trait_ref_and_return_type;
 use super::wf;
 use super::{
- ErrorReporting, ImplDerivedObligation, ImplDerivedObligationCause, Normalized, Obligation,
- ObligationCause, ObligationCauseCode, Overflow, PolyTraitObligation, PredicateObligation,
- Selection, SelectionError, SelectionResult, TraitQueryMode,
+ ImplDerivedObligation, ImplDerivedObligationCause, Normalized, Obligation, ObligationCause,
+ ObligationCauseCode, Overflow, PolyTraitObligation, PredicateObligation, Selection,
+ SelectionError, SelectionResult, TraitQueryMode,
 };
 
 use crate::infer::{InferCtxt, InferOk, TypeFreshener};
@@ -496,7 +496,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  }
  Ok(_) => Ok(None),
  Err(OverflowError::Canonical) => Err(Overflow(OverflowError::Canonical)),
- Err(OverflowError::ErrorReporting) => Err(ErrorReporting),
  Err(OverflowError::Error(e)) => Err(Overflow(OverflowError::Error(e))),
  })
  .flat_map(Result::transpose)
@@ -1233,7 +1232,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
  Ok(Some(c)) => self.evaluate_candidate(stack, &c),
  Ok(None) => Ok(EvaluatedToAmbig),
  Err(Overflow(OverflowError::Canonical)) => Err(OverflowError::Canonical),
- Err(ErrorReporting) => Err(OverflowError::ErrorReporting),
  Err(..) => Ok(EvaluatedToErr),
  }
  }

compiler/rustc_ty_utils/src/abi.rs

@@ -228,9 +228,9 @@ fn fn_sig_for_fn_abi<'tcx>(
 }
 
 #[inline]
-fn conv_from_spec_abi(tcx: TyCtxt<'_>, abi: SpecAbi) -> Conv {
+fn conv_from_spec_abi(tcx: TyCtxt<'_>, abi: SpecAbi, c_variadic: bool) -> Conv {
  use rustc_target::spec::abi::Abi::*;
- match tcx.sess.target.adjust_abi(abi) {
+ match tcx.sess.target.adjust_abi(abi, c_variadic) {
  RustIntrinsic | PlatformIntrinsic | Rust | RustCall => Conv::Rust,
 
  // This is intentionally not using `Conv::Cold`, as that has to preserve
@@ -488,7 +488,7 @@ fn fn_abi_new_uncached<'tcx>(
 ) -> Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, &'tcx FnAbiError<'tcx>> {
  let sig = cx.tcx.normalize_erasing_late_bound_regions(cx.param_env, sig);
 
- let conv = conv_from_spec_abi(cx.tcx(), sig.abi);
+ let conv = conv_from_spec_abi(cx.tcx(), sig.abi, sig.c_variadic);
 
  let mut inputs = sig.inputs();
  let extra_args = if sig.abi == RustCall {

library/core/src/primitive_docs.rs

@@ -1605,9 +1605,9 @@ mod prim_ref {}
 /// type in the function pointer to the type at the function declaration, and the return value is
 /// [`transmute`d][mem::transmute] from the type in the declaration to the type in the
 /// pointer. All the usual caveats and concerns around transmutation apply; for instance, if the
-/// function expects a `NonNullI32` and the function pointer uses the ABI-compatible type
-/// `Option<NonNullI32>`, and the value used for the argument is `None`, then this call is Undefined
-/// Behavior since transmuting `None::<NonNullI32>` to `NonNullI32` violates the non-null
+/// function expects a `NonZeroI32` and the function pointer uses the ABI-compatible type
+/// `Option<NonZeroI32>`, and the value used for the argument is `None`, then this call is Undefined
+/// Behavior since transmuting `None::<NonZeroI32>` to `NonZeroI32` violates the non-zero
 /// requirement.
 ///
 /// #### Requirements concerning target features

src/librustdoc/clean/blanket_impl.rs

@@ -81,7 +81,6 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
  match infcx.evaluate_obligation(&obligation) {
  Ok(eval_result) if eval_result.may_apply() => {}
  Err(traits::OverflowError::Canonical) => {}
- Err(traits::OverflowError::ErrorReporting) => {}
  _ => continue 'blanket_impls,
  }
  }