Add splat to libcore's TypeInfo

fixup! Impl TypeInfo for splat

Author: teor2345

compiler/rustc_const_eval/src/const_eval/type_info.rs

@@ -436,10 +436,17 @@ impl<'tcx> InterpCx<'tcx, CompileTimeMachine<'tcx>> {
                 sym::variadic => {
                     self.write_scalar(Scalar::from_bool(fn_sig_kind.c_variadic()), &field_place)?;
                 }
-                sym::splat => {
+                sym::is_splatted => {
+                    self.write_scalar(
+                        Scalar::from_bool(fn_sig_kind.splatted().is_some()),
+                        &field_place,
+                    )?;
+                }
+                sym::splatted_index => {
                     self.write_scalar(
-                        // Use the same encoding as FnSigKind.splatted
                         Scalar::from_u16(
+                            // Currently the same encoding as FnSigKind.splatted
+                            // FIXME(splat): make these two fields into a single Option<u16>, or choose a stable encoding
                             fn_sig_kind.splatted().unwrap_or(FnSigKind::NO_SPLATTED_ARG_INDEX),
                         ),
                         &field_place,

compiler/rustc_span/src/symbol.rs

@@ -1117,6 +1117,7 @@ symbols! {
         irrefutable_let_patterns,
         is,
         is_auto,
+        is_splatted,
         is_val_statically_known,
         isa_attribute,
         isize,
@@ -1952,6 +1953,7 @@ symbols! {
         speed,
         spirv,
         splat,
+        splatted_index,
         spotlight,
         sqrtf16,
         sqrtf32,

library/core/src/mem/type_info.rs

@@ -214,7 +214,7 @@ pub struct Variant {
     pub name: &'static str,
     /// All fields of the variant.
     pub fields: &'static [Field],
-    /// Whether the enum variant fields is non-exhaustive.
+    /// Whether the enum variant fields are non-exhaustive.
     pub non_exhaustive: bool,
 }
 
@@ -341,6 +341,22 @@ pub struct FnPtr {
 
     /// Vardiadic function, e.g. extern "C" fn add(n: usize, mut args: ...);
     pub variadic: bool,
+
+    // FIXME(splat): should these fields be private, or merged into an Option<u16>?
+    /// Is any function argument splatted?
+    pub is_splatted: bool,
+
+    /// The index of the splatted function argument in `inputs`, only valid if `is_splatted` is true.
+    /// e.g. in `fn overload(a: u8, #[splat] b: (f32, usize))` the index is 1, and it can be called
+    /// as `overload(a, 1.0, 2)`.
+    pub splatted_index: u16,
+}
+
+impl FnPtr {
+    /// Returns the splatted function argument index, or `None` if no argument is splatted.
+    pub const fn splatted(&self) -> Option<u16> {
+        if self.is_splatted { Some(self.splatted_index) } else { None }
+    }
 }
 
 #[derive(Debug, Default)]

library/coretests/tests/lib.rs

@@ -107,6 +107,7 @@
 #![feature(slice_shift)]
 #![feature(slice_split_once)]
 #![feature(sliceindex_wrappers)]
+#![feature(splat)]
 #![feature(split_array)]
 #![feature(split_as_slice)]
 #![feature(std_internals)]
@@ -129,6 +130,7 @@
 #![feature(widening_mul)]
 // tidy-alphabetical-end
 #![allow(internal_features)]
+#![expect(incomplete_features)]
 #![deny(fuzzy_provenance_casts)]
 #![deny(unsafe_op_in_unsafe_fn)]
 

library/coretests/tests/mem/fn_ptr.rs

@@ -5,6 +5,7 @@ const STRING_TY: TypeId = const { TypeId::of::<String>() };
 const U8_TY: TypeId = const { TypeId::of::<u8>() };
 const _U8_REF_TY: TypeId = const { TypeId::of::<&u8>() };
 const UNIT_TY: TypeId = const { TypeId::of::<()>() };
+const TUPLE_STRING_U8_TY: TypeId = const { TypeId::of::<(String, u8)>() };
 
 #[test]
 fn test_fn_ptrs() {
@@ -14,6 +15,8 @@ fn test_fn_ptrs() {
         inputs: &[],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<fn()>().kind })
     else {
         panic!();
@@ -31,6 +34,8 @@ fn test_ref() {
             inputs: &[ty1, ty2],
             output,
             variadic: false,
+            is_splatted: false,
+            splatted_index: _,
         }) = (const { Type::of::<fn(&u8, &u8)>().kind })
         else {
             panic!();
@@ -61,6 +66,8 @@ fn test_unsafe() {
         inputs: &[],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<unsafe fn()>().kind })
     else {
         panic!();
@@ -75,6 +82,8 @@ fn test_abi() {
         inputs: &[],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<extern "Rust" fn()>().kind })
     else {
         panic!();
@@ -87,6 +96,8 @@ fn test_abi() {
         inputs: &[],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<extern "C" fn()>().kind })
     else {
         panic!();
@@ -99,6 +110,8 @@ fn test_abi() {
         inputs: &[],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<unsafe extern "system" fn()>().kind })
     else {
         panic!();
@@ -114,6 +127,8 @@ fn test_inputs() {
         inputs: &[ty1, ty2],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<fn(String, u8)>().kind })
     else {
         panic!();
@@ -128,6 +143,8 @@ fn test_inputs() {
         inputs: &[ty1, ty2],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<fn(val: String, p2: u8)>().kind })
     else {
         panic!();
@@ -145,6 +162,8 @@ fn test_output() {
         inputs: &[],
         output,
         variadic: false,
+        is_splatted: false,
+        splatted_index: _,
     }) = (const { Type::of::<fn() -> u8>().kind })
     else {
         panic!();
@@ -160,10 +179,57 @@ fn test_variadic() {
         inputs: [ty1],
         output,
         variadic: true,
+        is_splatted: false,
+        splatted_index: _,
     }) = &(const { Type::of::<extern "C" fn(u8, ...)>().kind })
     else {
         panic!();
     };
     assert_eq!(output, &UNIT_TY);
     assert_eq!(*ty1, U8_TY);
 }
+
+#[test]
+fn test_splat() {
+    #[rustfmt::skip]
+    let TypeKind::FnPtr(fn_ptr_ty) = &(const { Type::of::<fn(#[splat] (String, u8))>().kind }) else {
+        panic!();
+    };
+    let FnPtr {
+        unsafety: false,
+        abi: Abi::ExternRust,
+        inputs: [ty1],
+        output,
+        variadic: false,
+        is_splatted: true,
+        splatted_index: 0,
+    } = fn_ptr_ty
+    else {
+        panic!();
+    };
+    assert_eq!(output, &UNIT_TY);
+    assert_eq!(*ty1, TUPLE_STRING_U8_TY);
+    assert_eq!(fn_ptr_ty.splatted(), Some(0));
+}
+
+#[test]
+fn test_not_splat() {
+    let TypeKind::FnPtr(fn_ptr_ty) = &(const { Type::of::<fn((String, u8))>().kind }) else {
+        panic!();
+    };
+    let FnPtr {
+        unsafety: false,
+        abi: Abi::ExternRust,
+        inputs: [ty1],
+        output,
+        variadic: false,
+        is_splatted: false,
+        splatted_index: _,
+    } = fn_ptr_ty
+    else {
+        panic!();
+    };
+    assert_eq!(output, &UNIT_TY);
+    assert_eq!(*ty1, TUPLE_STRING_U8_TY);
+    assert_eq!(fn_ptr_ty.splatted(), None);
+}