Rollup of 14 pull requests

compiler/rustc_abi/src/layout/ty.rs

@@ -7,7 +7,7 @@ use rustc_macros::StableHash;
 
 use crate::layout::{FieldIdx, VariantIdx};
 use crate::{
-    AbiAlign, Align, BackendRepr, FieldsShape, Float, HasDataLayout, LayoutData, Niche,
+    AbiAlign, Align, BackendRepr, FieldsShape, Float, HasDataLayout, LayoutData, Niche, Numeric,
     PointeeInfo, Primitive, Size, Variants,
 };
 
@@ -229,12 +229,12 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
     }
 
     /// Returns `true` if this type needs to match the ABI of the C `_Complex` type. See
-    /// [`TyAndLayout::complex_number_primitive`] for details.
+    /// [`TyAndLayout::complex_number`] for details.
     pub fn is_complex_number<C>(self, cx: &C) -> bool
     where
         Ty: TyAbiInterface<'a, C> + Copy,
     {
-        self.complex_number_primitive(cx).is_some()
+        self.complex_number(cx).is_some()
     }
 
     pub fn is_scalable_vector<C>(self) -> bool
@@ -302,9 +302,11 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
     }
 
     /// If this type should match the ABI of the C `_Complex` type, returns the primitive that is
-    /// used for its parts. This only returns `Some(T)` for `core::num::Complex<T>` where `T` is
+    /// used for its components.
+    ///
+    /// This function only returns `Some(T)` for `core::num::Complex<T>` where `T` is
     /// either a float or an integer. `repr(transparent)` wrapper types are automatically handled.
-    pub fn complex_number_primitive<C>(&self, cx: &C) -> Option<Primitive>
+    pub fn complex_number<C>(&self, cx: &C) -> Option<Numeric>
     where
         Ty: TyAbiInterface<'a, C> + Copy,
     {
@@ -313,35 +315,35 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
             return None;
         }
 
-        let part = complex.field(cx, 0).peel_transparent_wrappers(cx);
-
-        if let BackendRepr::Scalar(scalar) = part.backend_repr {
-            // Only Complex<{ float }> and Complex<{ integer }> have special layout.
-            let primitive = scalar.primitive();
-            match primitive {
-                // Explicitly spell out all the float types so that any new ones have to be added to
-                // one of the match branches.
-                Primitive::Int(..)
-                | Primitive::Float(Float::F16 | Float::F32 | Float::F64 | Float::F128) => {
-                    Some(primitive)
-                }
-                Primitive::Pointer(..) => None,
+        let component = complex.field(cx, 0).peel_transparent_wrappers(cx);
+
+        let BackendRepr::Scalar(scalar) = component.backend_repr else {
+            return None;
+        };
+
+        // Only Complex<{ float }> and Complex<{ integer }> have special layout.
+        //
+        // Explicitly spell out all the float types so that any new ones have to be added to
+        // one of the match branches.
+        let primitive = scalar.primitive();
+        match primitive {
+            Primitive::Int(integer, is_signed) => Some(Numeric::Int(integer, is_signed)),
+            Primitive::Float(float @ (Float::F16 | Float::F32 | Float::F64 | Float::F128)) => {
+                Some(Numeric::Float(float))
             }
-        } else {
-            None
+            Primitive::Pointer(..) => None,
         }
     }
 
-    /// Returns `Some` if this type has the ABI of the C `_Complex` type with float parts. See
-    /// [`TyAndLayout::complex_number_primitive`] for details.
+    /// Returns `Some` if this type has the ABI of the C `_Complex` type with float components.
+    /// See [`TyAndLayout::complex_number`] for details.
     pub fn complex_float<C>(&self, cx: &C) -> Option<Float>
     where
         Ty: TyAbiInterface<'a, C> + Copy,
     {
-        if let Some(Primitive::Float(float)) = self.complex_number_primitive(cx) {
-            Some(float)
-        } else {
-            None
+        match self.complex_number(cx) {
+            Some(Numeric::Float(float)) => Some(float),
+            _ => None,
         }
     }
 

compiler/rustc_abi/src/lib.rs

@@ -1451,6 +1451,31 @@ impl Float {
     }
 }
 
+/// Numeric primitives.
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "nightly", derive(StableHash))]
+pub enum Numeric {
+    /// The `bool` is the signedness of the `Integer` type.
+    Int(Integer, bool),
+    Float(Float),
+}
+
+impl Numeric {
+    pub fn size(self) -> Size {
+        match self {
+            Numeric::Int(integer, _) => integer.size(),
+            Numeric::Float(float) => float.size(),
+        }
+    }
+
+    pub fn reg_kind(self) -> RegKind {
+        match self {
+            Numeric::Int(_, _) => RegKind::Integer,
+            Numeric::Float(_) => RegKind::Float,
+        }
+    }
+}
+
 /// Fundamental unit of memory access and layout.
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "nightly", derive(StableHash))]

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -237,42 +237,39 @@ pub fn eval_config_entry(sess: &Session, cfg_entry: &CfgEntry) -> EvalConfigResu
             }
             EvalConfigResult::True
         }
-        CfgEntry::Any(subs, span) => {
+        CfgEntry::Any(subs, _) => {
             for sub in subs {
                 let res = eval_config_entry(sess, sub);
                 if res.as_bool() {
                     return res;
                 }
             }
-            EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
+            EvalConfigResult::False { reason: cfg_entry.clone() }
         }
-        CfgEntry::Not(sub, span) => {
+        CfgEntry::Not(sub, _) => {
             if eval_config_entry(sess, sub).as_bool() {
-                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
+                EvalConfigResult::False { reason: cfg_entry.clone() }
             } else {
                 EvalConfigResult::True
             }
         }
-        CfgEntry::Bool(b, span) => {
+        CfgEntry::Bool(b, _) => {
             if *b {
                 EvalConfigResult::True
             } else {
-                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
+                EvalConfigResult::False { reason: cfg_entry.clone() }
             }
         }
-        CfgEntry::NameValue { name, value, span } => {
+        CfgEntry::NameValue { name, value, span: _ } => {
             if sess.config.contains(&(*name, *value)) {
                 EvalConfigResult::True
             } else {
-                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
+                EvalConfigResult::False { reason: cfg_entry.clone() }
             }
         }
-        CfgEntry::Version(min_version, version_span) => {
+        CfgEntry::Version(min_version, _) => {
             let Some(min_version) = min_version else {
-                return EvalConfigResult::False {
-                    reason: cfg_entry.clone(),
-                    reason_span: *version_span,
-                };
+                return EvalConfigResult::False { reason: cfg_entry.clone() };
             };
             // See https://github.com/rust-lang/rust/issues/64796#issuecomment-640851454 for details
             let min_version_ok = if sess.opts.unstable_opts.assume_incomplete_release {
@@ -283,15 +280,15 @@ pub fn eval_config_entry(sess: &Session, cfg_entry: &CfgEntry) -> EvalConfigResu
             if min_version_ok {
                 EvalConfigResult::True
             } else {
-                EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *version_span }
+                EvalConfigResult::False { reason: cfg_entry.clone() }
             }
         }
     }
 }
 
 pub enum EvalConfigResult {
     True,
-    False { reason: CfgEntry, reason_span: Span },
+    False { reason: CfgEntry },
 }
 
 impl EvalConfigResult {

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -15,7 +15,8 @@ use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 use crate::attributes::AttributeSafety;
 use crate::parser::{AllowExprMetavar, MetaItemOrLitParser};
 use crate::{
-    AttributeParser, AttributeTemplate, ParsedDescription, ShouldEmit, diagnostics, parse_cfg_entry,
+    AttributeParser, AttributeTemplate, EvalConfigResult, ParsedDescription, ShouldEmit,
+    diagnostics, parse_cfg_entry,
 };
 
 #[derive(Clone)]
@@ -49,11 +50,16 @@ impl CfgSelectBranches {
     /// or the wildcard if none of the reachable branches satisfied the predicate.
     pub fn pop_first_match<F>(&mut self, predicate: F) -> Option<(CfgEntry, TokenStream, Span)>
     where
-        F: Fn(&CfgEntry) -> bool,
+        F: Fn(&CfgEntry) -> EvalConfigResult,
     {
-        for (index, (cfg, _, _)) in self.reachable.iter().enumerate() {
-            if predicate(cfg) {
-                return Some(self.reachable.remove(index));
+        for (index, (cfg, _, _)) in self.reachable.iter_mut().enumerate() {
+            match predicate(cfg) {
+                EvalConfigResult::True => {
+                    return Some(self.reachable.remove(index));
+                }
+                EvalConfigResult::False { reason } => {
+                    *cfg = reason;
+                }
             }
         }
 

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -3,7 +3,7 @@ use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{AttrKind, Expr, SyntheticAttr, ast};
 use rustc_attr_ir::CfgEntry;
 use rustc_attr_parsing as attr;
-use rustc_attr_parsing::{CfgSelectBranches, EvalConfigResult, parse_cfg_select};
+use rustc_attr_parsing::{CfgSelectBranches, parse_cfg_select};
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacResult, MacroExpanderResult};
 use rustc_expand::expand::DeclaredIdents;
 use rustc_span::{Ident, Span, sym};
@@ -129,9 +129,7 @@ pub(super) fn expand_cfg_select<'cx>(
         ) {
             Ok(mut branches) => {
                 if let Some((cfg_entry, selected_tts, selected_span)) =
-                    branches.pop_first_match(|cfg| {
-                        matches!(attr::eval_config_entry(ecx.sess, cfg), EvalConfigResult::True)
-                    })
+                    branches.pop_first_match(|cfg| attr::eval_config_entry(ecx.sess, cfg))
                 {
                     let mac = CfgSelectResult {
                         ecx,

compiler/rustc_expand/src/expand.rs

@@ -2366,13 +2366,13 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                         let res = self.expand_cfg_true(&mut node, attr, pos);
                         match res {
                             EvalConfigResult::True => continue,
-                            EvalConfigResult::False { reason, reason_span } => {
+                            EvalConfigResult::False { reason } => {
                                 for ident in node.declared_idents() {
                                     self.cx.resolver.append_stripped_cfg_item(
                                         self.cx.current_expansion.lint_node_id,
                                         ident,
                                         reason.clone(),
-                                        reason_span,
+                                        reason.span(),
                                     )
                                 }
                             }