ported compiler test cases to #[rust_intrinsic]

Author: BLANKatGITHUB

compiler/rustc_error_codes/src/error_codes/E0092.md

@@ -6,10 +6,10 @@ Erroneous code example:
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    fn atomic_foo(); // error: unrecognized atomic operation
-                     //        function
-}
+#[rustc_intrinsic]
+unsafe fn atomic_foo(); // error: unrecognized atomic operation
+                  //        function
+
 ```
 
 Please check you didn't make a mistake in the function's name. All intrinsic
@@ -20,7 +20,7 @@ functions are defined in `compiler/rustc_codegen_llvm/src/intrinsic.rs` and in
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    fn atomic_fence_seqcst(); // ok!
-}
+#[rustc_intrinsic]
+unsafe fn atomic_fence_seqcst(); // ok!
+
 ```

compiler/rustc_error_codes/src/error_codes/E0093.md

@@ -6,9 +6,9 @@ Erroneous code example:
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    fn foo(); // error: unrecognized intrinsic function: `foo`
-}
+#[rustc_intrinsic]
+unsafe fn foo(); // error: unrecognized intrinsic function: `foo`
+
 
 fn main() {
     unsafe {
@@ -25,9 +25,9 @@ functions are defined in `compiler/rustc_codegen_llvm/src/intrinsic.rs` and in
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    fn atomic_fence_seqcst(); // ok!
-}
+#[rustc_intrinsic]
+unsafe fn atomic_fence_seqcst(); // ok!
+
 
 fn main() {
     unsafe {

compiler/rustc_error_codes/src/error_codes/E0211.md

@@ -7,9 +7,9 @@ used. Erroneous code examples:
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    fn unreachable(); // error: intrinsic has wrong type
-}
+#[rustc_intrinsic]
+unsafe fn unreachable(); // error: intrinsic has wrong type
+
 
 // or:
 
@@ -43,9 +43,9 @@ For the first code example, please check the function definition. Example:
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    fn unreachable() -> !; // ok!
-}
+#[rustc_intrinsic]
+unsafe fn unreachable() -> !; // ok!
+
 ```
 
 The second case example is a bit particular: the main function must always

compiler/rustc_error_codes/src/error_codes/E0511.md

@@ -5,9 +5,9 @@ Erroneous code example:
 ```compile_fail,E0511
 #![feature(intrinsics)]
 
-extern "rust-intrinsic" {
-    fn simd_add<T>(a: T, b: T) -> T;
-}
+#[rustc_intrinsic]
+unsafe fn simd_add<T>(_a: T, _b: T) -> T;
+
 
 fn main() {
     unsafe { simd_add(0, 1); }
@@ -25,9 +25,9 @@ The generic type has to be a SIMD type. Example:
 #[derive(Copy, Clone)]
 struct i32x2([i32; 2]);
 
-extern "rust-intrinsic" {
-    fn simd_add<T>(a: T, b: T) -> T;
-}
+#[rustc_intrinsic]
+unsafe fn simd_add<T>(_a: T, _b: T) -> T;
+
 
 unsafe { simd_add(i32x2([0, 0]), i32x2([1, 2])); } // ok!
 ```

compiler/rustc_error_codes/src/error_codes/E0622.md

@@ -6,10 +6,10 @@ Erroneous code example:
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    pub static atomic_singlethreadfence_seqcst: fn();
-    // error: intrinsic must be a function
-}
+#[rustc_intrinsic]
+pub static atomic_singlethreadfence_seqcst: fn();
+// error: intrinsic must be a function
+
 
 fn main() { unsafe { atomic_singlethreadfence_seqcst(); } }
 ```
@@ -22,9 +22,9 @@ error, just declare a function. Example:
 #![feature(intrinsics)]
 #![allow(internal_features)]
 
-extern "rust-intrinsic" {
-    pub fn atomic_singlethreadfence_seqcst(); // ok!
-}
+#[rustc_intrinsic]
+pub unsafe fn atomic_singlethreadfence_seqcst(); // ok!
+
 
 fn main() { unsafe { atomic_singlethreadfence_seqcst(); } }
 ```