Auto merge of #133006 - matthiaskrgr:rollup-dz6oiq5, r=matthiaskrgr

Rollup of 8 pull requests
Successful merges:
- #126046 (Implement `mixed_integer_ops_unsigned_sub`)
- #132302 (rustdoc: Treat declarative macros more like other item kinds)
- #132842 (ABI checks: add support for tier2 arches)
- #132995 (compiletest: Add ``exact-llvm-major-version`` directive)
- #132996 (Trim extra space when suggesting removing bad `let`)
- #132998 (Unvacation myself)
- #133000 ([rustdoc] Fix duplicated footnote IDs)
- #133001 (actually test next solver)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_monomorphize/messages.ftl

@@ -1,12 +1,19 @@
 monomorphize_abi_error_disabled_vector_type_call =
-ABI error: this function call uses a vector type that requires the `{$required_feature}` target feature, which is not enabled in the caller
+ this function call uses a SIMD vector type that (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled in the caller
 .label = function called here
 .help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`)
 monomorphize_abi_error_disabled_vector_type_def =
-ABI error: this function definition uses a vector type that requires the `{$required_feature}` target feature, which is not enabled
+ this function definition uses a SIMD vector type that (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled
 .label = function defined here
 .help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`)
 
+monomorphize_abi_error_unsupported_vector_type_call =
+ this function call uses a SIMD vector type that is not currently supported with the chosen ABI
+.label = function called here
+monomorphize_abi_error_unsupported_vector_type_def =
+ this function definition uses a SIMD vector type that is not currently supported with the chosen ABI
+.label = function defined here
+
 monomorphize_couldnt_dump_mono_stats =
  unexpected error occurred while dumping monomorphization stats: {$error}
 

compiler/rustc_monomorphize/src/errors.rs

@@ -110,3 +110,17 @@ pub(crate) struct AbiErrorDisabledVectorTypeCall<'a> {
 pubspan:Span,
 pubrequired_feature:&'astr,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(monomorphize_abi_error_unsupported_vector_type_def)]
+pub(crate)structAbiErrorUnsupportedVectorTypeDef{
+#[label]
+pubspan:Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(monomorphize_abi_error_unsupported_vector_type_call)]
+pub(crate)structAbiErrorUnsupportedVectorTypeCall{
+#[label]
+pubspan:Span,
+}

compiler/rustc_monomorphize/src/mono_checks/abi_check.rs

@@ -10,7 +10,10 @@ use rustc_span::{DUMMY_SP, Span, Symbol};
 use rustc_target::abi::call::{FnAbi,PassMode};
 use rustc_target::abi::{BackendRepr,RegKind};
 
-usecrate::errors::{AbiErrorDisabledVectorTypeCall,AbiErrorDisabledVectorTypeDef};
+usecrate::errors::{
+AbiErrorDisabledVectorTypeCall,AbiErrorDisabledVectorTypeDef,
+AbiErrorUnsupportedVectorTypeCall,AbiErrorUnsupportedVectorTypeDef,
+};
 
 fnuses_vector_registers(mode:&PassMode,repr:&BackendRepr) -> bool{
 match mode {
@@ -23,11 +26,15 @@ fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool {
 }
 }
 
+/// Checks whether a certain function ABI is compatible with the target features currently enabled
+/// for a certain function.
+/// If not, `emit_err` is called, with `Some(feature)` if a certain feature should be enabled and
+/// with `None` if no feature is known that would make the ABI compatible.
 fndo_check_abi<'tcx>(
 tcx:TyCtxt<'tcx>,
 abi:&FnAbi<'tcx,Ty<'tcx>>,
 target_feature_def:DefId,
-mutemit_err:implFnMut(&'staticstr),
+mutemit_err:implFnMut(Option<&'staticstr>),
 ){
 letSome(feature_def) = tcx.sess.target.features_for_correct_vector_abi()else{
 return;
@@ -40,15 +47,15 @@ fn do_check_abi<'tcx>(
 let feature = match feature_def.iter().find(|(bits, _)| size.bits() <= *bits){
 Some((_, feature)) => feature,
 None => {
-emit_err("<no available feature for this size>");
+emit_err(None);
 continue;
 }
 };
 let feature_sym = Symbol::intern(feature);
 if !tcx.sess.unstable_target_features.contains(&feature_sym)
  && !codegen_attrs.target_features.iter().any(|x| x.name == feature_sym)
 {
-emit_err(feature);
+emit_err(Some(&feature));
 }
 }
 }
@@ -65,12 +72,21 @@ fn check_instance_abi<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) {
 };
 do_check_abi(tcx, abi, instance.def_id(), |required_feature| {
 let span = tcx.def_span(instance.def_id());
- tcx.emit_node_span_lint(
-ABI_UNSUPPORTED_VECTOR_TYPES,
-CRATE_HIR_ID,
- span,
-AbiErrorDisabledVectorTypeDef{ span, required_feature },
-);
+ifletSome(required_feature) = required_feature {
+ tcx.emit_node_span_lint(
+ABI_UNSUPPORTED_VECTOR_TYPES,
+CRATE_HIR_ID,
+ span,
+AbiErrorDisabledVectorTypeDef{ span, required_feature },
+);
+}else{
+ tcx.emit_node_span_lint(
+ABI_UNSUPPORTED_VECTOR_TYPES,
+CRATE_HIR_ID,
+ span,
+AbiErrorUnsupportedVectorTypeDef{ span },
+);
+}
 })
 }
 
@@ -109,12 +125,21 @@ fn check_call_site_abi<'tcx>(
 return;
 };
 do_check_abi(tcx, callee_abi, caller.def_id(), |required_feature| {
- tcx.emit_node_span_lint(
-ABI_UNSUPPORTED_VECTOR_TYPES,
-CRATE_HIR_ID,
- span,
-AbiErrorDisabledVectorTypeCall{ span, required_feature },
-);
+ifletSome(required_feature) = required_feature {
+ tcx.emit_node_span_lint(
+ABI_UNSUPPORTED_VECTOR_TYPES,
+CRATE_HIR_ID,
+ span,
+AbiErrorDisabledVectorTypeCall{ span, required_feature },
+);
+}else{
+ tcx.emit_node_span_lint(
+ABI_UNSUPPORTED_VECTOR_TYPES,
+CRATE_HIR_ID,
+ span,
+AbiErrorUnsupportedVectorTypeCall{ span },
+);
+}
 });
 }
 

compiler/rustc_parse/src/parser/pat.rs

@@ -683,7 +683,9 @@ impl<'a> Parser<'a> {
 })
 {
 self.bump();
-self.dcx().emit_err(RemoveLet{span: lo });
+// Trim extra space after the `let`
+let span = lo.with_hi(self.token.span.lo());
+self.dcx().emit_err(RemoveLet{ span });
  lo = self.token.span;
 }
 

compiler/rustc_target/src/target_features.rs

@@ -586,9 +586,20 @@ pub fn all_rust_features() -> impl Iterator<Item = (&'static str, Stability)> {
 // certain size to have their "proper" ABI on each architecture.
 // Note that they must be kept sorted by vector size.
 constX86_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] =
-&[(128,"sse"),(256,"avx"),(512,"avx512f")];
+&[(128,"sse"),(256,"avx"),(512,"avx512f")];// FIXME: might need changes for AVX10.
 constAARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] = &[(128,"neon")];
 
+// We might want to add "helium" too.
+constARM_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] = &[(128,"neon")];
+
+constPOWERPC_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] = &[(128,"altivec")];
+constWASM_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] = &[(128,"simd128")];
+constS390X_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] = &[(128,"vector")];
+constRISCV_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] =
+&[/*(64, "zvl64b"), */(128,"v")];
+// Always warn on SPARC, as the necessary target features cannot be enabled in Rust at the moment.
+constSPARC_FEATURES_FOR_CORRECT_VECTOR_ABI:&'static[(u64,&'staticstr)] = &[/*(128, "vis")*/];
+
 implsuper::spec::Target{
 pubfnrust_target_features(&self) -> &'static[(&'staticstr,Stability,ImpliedFeatures)]{
 match&*self.arch{
@@ -613,8 +624,15 @@ impl super::spec::Target {
 pubfnfeatures_for_correct_vector_abi(&self) -> Option<&'static[(u64,&'staticstr)]>{
 match&*self.arch{
 "x86" | "x86_64" => Some(X86_FEATURES_FOR_CORRECT_VECTOR_ABI),
-"aarch64" => Some(AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI),
-// FIXME: add support for non-tier1 architectures
+"aarch64" | "arm64ec" => Some(AARCH64_FEATURES_FOR_CORRECT_VECTOR_ABI),
+"arm" => Some(ARM_FEATURES_FOR_CORRECT_VECTOR_ABI),
+"powerpc" | "powerpc64" => Some(POWERPC_FEATURES_FOR_CORRECT_VECTOR_ABI),
+"loongarch64" => Some(&[]),// on-stack ABI, so we complain about all by-val vectors
+"riscv32" | "riscv64" => Some(RISCV_FEATURES_FOR_CORRECT_VECTOR_ABI),
+"wasm32" | "wasm64" => Some(WASM_FEATURES_FOR_CORRECT_VECTOR_ABI),
+"s390x" => Some(S390X_FEATURES_FOR_CORRECT_VECTOR_ABI),
+"sparc" | "sparc64" => Some(SPARC_FEATURES_FOR_CORRECT_VECTOR_ABI),
+// FIXME: add support for non-tier2 architectures
  _ => None,
 }
 }

library/core/src/num/uint_macros.rs

@@ -763,6 +763,33 @@ macro_rules! uint_impl {
 }
 }
 
+/// Checked subtraction with a signed integer. Computes `self - rhs`,
+/// returning `None` if overflow occurred.
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// #![feature(mixed_integer_ops_unsigned_sub)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".checked_sub_signed(2), None);")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".checked_sub_signed(-2), Some(3));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT),"::MAX - 2).checked_sub_signed(-4), None);")]
+/// ```
+ #[unstable(feature = "mixed_integer_ops_unsigned_sub", issue = "126043")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+pubconstfn checked_sub_signed(self, rhs: $SignedT) -> Option<Self> {
+let(res, overflow) = self.overflowing_sub_signed(rhs);
+
+if !overflow {
+Some(res)
+} else {
+None
+}
+}
+
  #[doc = concat!(
 "Checked integer subtraction. Computes `self - rhs` and checks if the result fits into an [`",
  stringify!($SignedT),"`], returning `None` if overflow occurred."
@@ -1793,6 +1820,35 @@ macro_rules! uint_impl {
  intrinsics::saturating_sub(self, rhs)
 }
 
+/// Saturating integer subtraction. Computes `self` - `rhs`, saturating at
+/// the numeric bounds instead of overflowing.
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// #![feature(mixed_integer_ops_unsigned_sub)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".saturating_sub_signed(2), 0);")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".saturating_sub_signed(-2), 3);")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT),"::MAX - 2).saturating_sub_signed(-4), ", stringify!($SelfT),"::MAX);")]
+/// ```
+ #[unstable(feature = "mixed_integer_ops_unsigned_sub", issue = "126043")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+pubconstfn saturating_sub_signed(self, rhs: $SignedT) -> Self{
+let(res, overflow) = self.overflowing_sub_signed(rhs);
+
+if !overflow {
+ res
+} else if rhs < 0{
+Self::MAX
+} else {
+0
+}
+}
+
 /// Saturating integer multiplication. Computes `self * rhs`,
 /// saturating at the numeric bounds instead of overflowing.
 ///
@@ -1926,6 +1982,27 @@ macro_rules! uint_impl {
  intrinsics::wrapping_sub(self, rhs)
 }
 
+/// Wrapping (modular) subtraction with a signed integer. Computes
+/// `self - rhs`, wrapping around at the boundary of the type.
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// #![feature(mixed_integer_ops_unsigned_sub)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".wrapping_sub_signed(2), ", stringify!($SelfT),"::MAX);")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".wrapping_sub_signed(-2), 3);")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT),"::MAX - 2).wrapping_sub_signed(-4), 1);")]
+/// ```
+ #[unstable(feature = "mixed_integer_ops_unsigned_sub", issue = "126043")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+pubconstfn wrapping_sub_signed(self, rhs: $SignedT) -> Self{
+self.wrapping_sub(rhs asSelf)
+}
+
 /// Wrapping (modular) multiplication. Computes `self *
 /// rhs`, wrapping around at the boundary of the type.
 ///
@@ -2378,6 +2455,32 @@ macro_rules! uint_impl {
 (c, b || d)
 }
 
+/// Calculates `self` - `rhs` with a signed `rhs`
+///
+/// Returns a tuple of the subtraction along with a boolean indicating
+/// whether an arithmetic overflow would occur. If an overflow would
+/// have occurred then the wrapped value is returned.
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// #![feature(mixed_integer_ops_unsigned_sub)]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".overflowing_sub_signed(2), (", stringify!($SelfT),"::MAX, true));")]
+ #[doc = concat!("assert_eq!(1", stringify!($SelfT),".overflowing_sub_signed(-2), (3, false));")]
+ #[doc = concat!("assert_eq!((", stringify!($SelfT),"::MAX - 2).overflowing_sub_signed(-4), (1, true));")]
+/// ```
+ #[unstable(feature = "mixed_integer_ops_unsigned_sub", issue = "126043")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+pubconstfn overflowing_sub_signed(self, rhs: $SignedT) -> (Self,bool){
+let(res, overflow) = self.overflowing_sub(rhs asSelf);
+
+(res, overflow ^ (rhs < 0))
+}
+
 /// Computes the absolute difference between `self` and `other`.
 ///
 /// # Examples

src/librustdoc/clean/inline.rs

@@ -134,11 +134,7 @@ pub(crate) fn try_inline(
 })
 }
 Res::Def(DefKind::Macro(kind), did) => {
-let is_doc_hidden = cx.tcx.is_doc_hidden(did)
- || attrs_without_docs
-.map(|(attrs, _)| attrs)
-.is_some_and(|attrs| utils::attrs_have_doc_flag(attrs.iter(), sym::hidden));
-let mac = build_macro(cx, did, name, import_def_id, kind, is_doc_hidden);
+let mac = build_macro(cx, did, name, kind);
 
 let type_kind = match kind {
 MacroKind::Bang => ItemType::Macro,
@@ -740,18 +736,14 @@ fn build_macro(
 cx:&mutDocContext<'_>,
 def_id:DefId,
 name:Symbol,
-import_def_id:Option<LocalDefId>,
 macro_kind:MacroKind,
-is_doc_hidden:bool,
 ) -> clean::ItemKind{
 matchCStore::from_tcx(cx.tcx).load_macro_untracked(def_id, cx.tcx){
 LoadedMacro::MacroDef{ def, .. } => match macro_kind {
-MacroKind::Bang => {
-let vis = cx.tcx.visibility(import_def_id.map(|d| d.to_def_id()).unwrap_or(def_id));
- clean::MacroItem(clean::Macro{
-source: utils::display_macro_source(cx, name,&def, def_id, vis, is_doc_hidden),
-})
-}
+MacroKind::Bang => clean::MacroItem(clean::Macro{
+source: utils::display_macro_source(cx, name,&def),
+macro_rules: def.macro_rules,
+}),
 MacroKind::Derive | MacroKind::Attr => {
  clean::ProcMacroItem(clean::ProcMacro{kind: macro_kind,helpers:Vec::new()})
 }

src/librustdoc/clean/mod.rs

@@ -2787,13 +2787,10 @@ fn clean_maybe_renamed_item<'tcx>(
 fields: variant_data.fields().iter().map(|x| clean_field(x, cx)).collect(),
 }),
 ItemKind::Impl(impl_) => returnclean_impl(impl_, item.owner_id.def_id, cx),
-ItemKind::Macro(macro_def,MacroKind::Bang) => {
-let ty_vis = cx.tcx.visibility(def_id);
-MacroItem(Macro{
-// FIXME this shouldn't be false
-source:display_macro_source(cx, name, macro_def, def_id, ty_vis,false),
-})
-}
+ItemKind::Macro(macro_def,MacroKind::Bang) => MacroItem(Macro{
+source:display_macro_source(cx, name, macro_def),
+macro_rules: macro_def.macro_rules,
+}),
 ItemKind::Macro(_, macro_kind) => clean_proc_macro(item,&mut name, macro_kind, cx),
 // proc macros can have a name set by attributes
 ItemKind::Fn(ref sig, generics, body_id) => {

src/librustdoc/clean/types.rs

@@ -2543,6 +2543,8 @@ pub(crate) struct ImportSource {
 #[derive(Clone,Debug)]
 pub(crate)structMacro{
 pub(crate)source:String,
+/// Whether the macro was defined via `macro_rules!` as opposed to `macro`.
+pub(crate)macro_rules:bool,
 }
 
 #[derive(Clone,Debug)]