Reverted rust-analyser based on Ralph's comments

Author: vayunbiyani

src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests.rs

@@ -2527,8 +2527,9 @@ fn const_transfer_memory() {
 fn anonymous_const_block() {
     check_number(
         r#"
-    #[rustc_intrinsic]
-    pub fn size_of<T>() -> usize;
+    extern "rust-intrinsic" {
+        pub fn size_of<T>() -> usize;
+    }
 
     const fn f<T>() -> usize {
         let r = const { size_of::<T>() };

src/tools/rust-analyzer/crates/hir-ty/src/consteval/tests/intrinsics.rs

@@ -204,12 +204,12 @@ fn const_eval_select() {
     check_number(
         r#"
         //- minicore: fn
-        #[rustc_intrinsic]
-        pub unsafe fn const_eval_select<ARG, F, G, RET>(arg: ARG, called_in_const: F, called_at_rt: G) -> RET
-        where
-            G: FnOnce<ARG, Output = RET>,
-            F: FnOnce<ARG, Output = RET>;
-        
+        extern "rust-intrinsic" {
+            pub fn const_eval_select<ARG, F, G, RET>(arg: ARG, called_in_const: F, called_at_rt: G) -> RET
+            where
+                G: FnOnce<ARG, Output = RET>,
+                F: FnOnce<ARG, Output = RET>;
+        }
 
         const fn in_const(x: i32, y: i32) -> i32 {
             x + y
@@ -229,9 +229,9 @@ fn const_eval_select() {
 fn wrapping_add() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn wrapping_add<T>(a: T, b: T) -> T;
-
+        extern "rust-intrinsic" {
+            pub fn wrapping_add<T>(a: T, b: T) -> T;
+        }
 
         const GOAL: u8 = wrapping_add(10, 250);
         "#,
@@ -244,12 +244,10 @@ fn ptr_offset_from() {
     check_number(
         r#"
         //- minicore: index, slice, coerce_unsized
-
-        #[rustc_intrinsic]
-        pub unsafe fn ptr_offset_from<T>(ptr: *const T, base: *const T) -> isize;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn ptr_offset_from_unsigned<T>(ptr: *const T, base: *const T) -> usize;
+        extern "rust-intrinsic" {
+            pub fn ptr_offset_from<T>(ptr: *const T, base: *const T) -> isize;
+            pub fn ptr_offset_from_unsigned<T>(ptr: *const T, base: *const T) -> usize;
+        }
 
         const GOAL: isize = {
             let x = [1, 2, 3, 4, 5i32];
@@ -267,26 +265,29 @@ fn ptr_offset_from() {
 fn saturating() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn saturating_add<T>(a: T, b: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn saturating_add<T>(a: T, b: T) -> T;
+        }
 
         const GOAL: u8 = saturating_add(10, 250);
         "#,
         255,
     );
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn saturating_sub<T>(a: T, b: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn saturating_sub<T>(a: T, b: T) -> T;
+        }
 
         const GOAL: bool = saturating_sub(5u8, 7) == 0 && saturating_sub(8u8, 4) == 4;
         "#,
         1,
     );
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn saturating_add<T>(a: T, b: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn saturating_add<T>(a: T, b: T) -> T;
+        }
 
         const GOAL: i8 = saturating_add(5, 8);
         "#,
@@ -329,17 +330,19 @@ fn allocator() {
 fn overflowing_add() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn add_with_overflow<T>(x: T, y: T) -> (T, bool);
+        extern "rust-intrinsic" {
+            pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool);
+        }
 
         const GOAL: u8 = add_with_overflow(1, 2).0;
         "#,
         3,
     );
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn add_with_overflow<T>(x: T, y: T) -> (T, bool);
+        extern "rust-intrinsic" {
+            pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool);
+        }
 
         const GOAL: u8 = add_with_overflow(1, 2).1 as u8;
         "#,
@@ -352,9 +355,9 @@ fn needs_drop() {
     check_number(
         r#"
         //- minicore: copy, sized
-        #[rustc_intrinsic]
-        pub unsafe fn needs_drop<T: ?Sized>() -> bool;
-
+        extern "rust-intrinsic" {
+            pub fn needs_drop<T: ?Sized>() -> bool;
+        }
         struct X;
         const GOAL: bool = !needs_drop::<i32>() && needs_drop::<X>();
         "#,
@@ -368,9 +371,9 @@ fn discriminant_value() {
         r#"
         //- minicore: discriminant, option
         use core::marker::DiscriminantKind;
-        #[rustc_intrinsic]
-        pub unsafe fn discriminant_value<T>(v: &T) -> <T as DiscriminantKind>::Discriminant;
-
+        extern "rust-intrinsic" {
+            pub fn discriminant_value<T>(v: &T) -> <T as DiscriminantKind>::Discriminant;
+        }
         const GOAL: bool = {
             discriminant_value(&Some(2i32)) == discriminant_value(&Some(5i32))
                 && discriminant_value(&Some(2i32)) != discriminant_value(&None::<i32>)
@@ -405,15 +408,11 @@ fn floating_point() {
     // FIXME(#17451): Add `f16` and `f128` tests once intrinsics are added.
     check_number(
         r#"
-
-        #[rustc_intrinsic]
-        pub unsafe fn sqrtf32(x: f32) -> f32;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn powf32(a: f32, x: f32) -> f32;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn fmaf32(a: f32, b: f32, c: f32) -> f32;
+        extern "rust-intrinsic" {
+            pub fn sqrtf32(x: f32) -> f32;
+            pub fn powf32(a: f32, x: f32) -> f32;
+            pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
+        }
 
         const GOAL: f32 = sqrtf32(1.2) + powf32(3.4, 5.6) + fmaf32(-7.8, 1.3, 2.4);
         "#,
@@ -425,15 +424,11 @@ fn floating_point() {
     #[allow(unknown_lints, clippy::unnecessary_min_or_max)]
     check_number(
         r#"
-
-        #[rustc_intrinsic]
-        pub unsafe fn powif64(a: f64, x: i32) -> f64;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn sinf64(x: f64) -> f64;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn minnumf64(x: f64, y: f64) -> f64;
+        extern "rust-intrinsic" {
+            pub fn powif64(a: f64, x: i32) -> f64;
+            pub fn sinf64(x: f64) -> f64;
+            pub fn minnumf64(x: f64, y: f64) -> f64;
+        }
 
         const GOAL: f64 = powif64(1.2, 5) + sinf64(3.4) + minnumf64(-7.8, 1.3);
         "#,
@@ -449,45 +444,21 @@ fn atomic() {
     check_number(
         r#"
         //- minicore: copy
-
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_load_seqcst<T: Copy>(src: *const T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_xchg_acquire<T: Copy>(dst: *mut T, src: T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_cxchg_release_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_cxchgweak_acquire_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_store_release<T: Copy>(dst: *mut T, val: T);
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_xadd_acqrel<T: Copy>(dst: *mut T, src: T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_xsub_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_and_acquire<T: Copy>(dst: *mut T, src: T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_nand_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_or_release<T: Copy>(dst: *mut T, src: T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_xor_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_fence_seqcst();
-        
-        #[rustc_intrinsic]
-        pub unsafe fn atomic_singlethreadfence_acqrel();
+        extern "rust-intrinsic" {
+            pub fn atomic_load_seqcst<T: Copy>(src: *const T) -> T;
+            pub fn atomic_xchg_acquire<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_cxchg_release_seqcst<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+            pub fn atomic_cxchgweak_acquire_acquire<T: Copy>(dst: *mut T, old: T, src: T) -> (T, bool);
+            pub fn atomic_store_release<T: Copy>(dst: *mut T, val: T);
+            pub fn atomic_xadd_acqrel<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_xsub_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_and_acquire<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_nand_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_or_release<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_xor_seqcst<T: Copy>(dst: *mut T, src: T) -> T;
+            pub fn atomic_fence_seqcst();
+            pub fn atomic_singlethreadfence_acqrel();
+        }
 
         fn should_not_reach() {
             _ // fails the test if executed
@@ -523,12 +494,10 @@ fn offset() {
     check_number(
         r#"
         //- minicore: coerce_unsized, index, slice
-
-        #[rustc_intrinsic]
-        pub unsafe fn offset<Ptr, Delta>(dst: Ptr, offset: Delta) -> Ptr;
-
-        #[rustc_intrinsic]
-        pub unsafe fn arith_offset<T>(dst: *const T, offset: isize) -> *const T;
+        extern "rust-intrinsic" {
+            pub fn offset<Ptr, Delta>(dst: Ptr, offset: Delta) -> Ptr;
+            pub fn arith_offset<T>(dst: *const T, offset: isize) -> *const T;
+        }
 
         const GOAL: i32 = unsafe {
             let ar: &[(i32, i32, i32)] = &[
@@ -554,8 +523,9 @@ fn arith_offset() {
     check_number(
         r#"
         //- minicore: coerce_unsized, index, slice
-        #[rustc_intrinsic]
-        pub unsafe fn arith_offset<T>(dst: *const T, offset: isize) -> *const T;
+        extern "rust-intrinsic" {
+            pub fn arith_offset<T>(dst: *const T, offset: isize) -> *const T;
+        }
 
         const GOAL: u8 = unsafe {
             let ar: &[(u8, u8, u8)] = &[
@@ -579,8 +549,9 @@ fn arith_offset() {
 fn copy_nonoverlapping() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
+        extern "rust-intrinsic" {
+            pub fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
+        }
 
         const GOAL: u8 = unsafe {
             let mut x = 2;
@@ -597,8 +568,9 @@ fn copy_nonoverlapping() {
 fn write_bytes() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
+        extern "rust-intrinsic" {
+            fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
+        }
 
         const GOAL: i32 = unsafe {
             let mut x = 2;
@@ -614,8 +586,9 @@ fn write_bytes() {
 fn write_via_move() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        unsafe fn write_via_move<T>(ptr: *mut T, value: T);
+        extern "rust-intrinsic" {
+            fn write_via_move<T>(ptr: *mut T, value: T);
+        }
 
         const GOAL: i32 = unsafe {
             let mut x = 2;
@@ -632,8 +605,9 @@ fn copy() {
     check_number(
         r#"
         //- minicore: coerce_unsized, index, slice
-        #[rustc_intrinsic]
-        pub unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize);
+        extern "rust-intrinsic" {
+            pub fn copy<T>(src: *const T, dst: *mut T, count: usize);
+        }
 
         const GOAL: i32 = unsafe {
             let mut x = [1i32, 2, 3, 4, 5];
@@ -651,8 +625,9 @@ fn copy() {
 fn ctpop() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn ctpop<T: Copy>(x: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn ctpop<T: Copy>(x: T) -> T;
+        }
 
         const GOAL: i64 = ctpop(-29);
         "#,
@@ -664,8 +639,9 @@ fn ctpop() {
 fn ctlz() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn ctlz<T: Copy>(x: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn ctlz<T: Copy>(x: T) -> T;
+        }
 
         const GOAL: u8 = ctlz(0b0001_1100_u8);
         "#,
@@ -677,8 +653,9 @@ fn ctlz() {
 fn cttz() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn cttz<T: Copy>(x: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn cttz<T: Copy>(x: T) -> T;
+        }
 
         const GOAL: i64 = cttz(-24);
         "#,
@@ -690,26 +667,28 @@ fn cttz() {
 fn rotate() {
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn rotate_left<T: Copy>(x: T, y: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn rotate_left<T: Copy>(x: T, y: T) -> T;
+        }
 
         const GOAL: i64 = rotate_left(0xaa00000000006e1i64, 12);
         "#,
         0x6e10aa,
     );
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn rotate_right<T: Copy>(x: T, y: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn rotate_right<T: Copy>(x: T, y: T) -> T;
+        }
 
         const GOAL: i64 = rotate_right(0x6e10aa, 12);
         "#,
         0xaa00000000006e1,
     );
     check_number(
         r#"
-        #[rustc_intrinsic]
-        pub unsafe fn rotate_left<T: Copy>(x: T, y: T) -> T;
+        extern "rust-intrinsic" {
+            pub fn rotate_left<T: Copy>(x: T, y: T) -> T;
         }
 
         const GOAL: i8 = rotate_left(129, 2);